SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
SLåR TILBAKE:
-
Russestøy: - Klarer ikke følge opp alle
-
Oslo: Melding om mulig skudd på et utested
-
Ukraina: Angrep mot boligområde
-
Russisk minister pågrepet
-
15 unge jenter i slagsmål
-
Skutt på Holmlia - vil ikke å forklare seg
-
Viktig Ukraina-pakke har fått flertall i Senatet i USA
-
Trafikkulykke på Nesodden: - Framstår alvorlig
-
NRK: Tre aktivister pågrepet for å ha fulgt etter Sylvi Listhaug
-
Åpnet cannabiskafé: Siktet
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
AKKURAT NÅ:
POLITIET:
Oslo: Mulig skudd på utested
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
AKKURAT NÅ:
RUSSEBRÅK:
- Klarer ikke følge opp alle
["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .hSeFXV.hSeFXV.hSeFXV.hSeFXV{height:0;padding-bottom:56.9%;}/*!sc*/ .jAfxuR.jAfxuR.jAfxuR.jAfxuR{height:0;padding-bottom:57.11%;}/*!sc*/ .eAYXY.eAYXY.eAYXY.eAYXY{height:0;padding-bottom:58.75%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .fJEMj.fJEMj.fJEMj.fJEMj{height:0;padding-bottom:92.03%;}/*!sc*/ .gmpxUf.gmpxUf.gmpxUf.gmpxUf{height:0;padding-bottom:55.62%;}/*!sc*/ .bkaZqA.bkaZqA.bkaZqA.bkaZqA{height:0;padding-bottom:64.32%;}/*!sc*/ .ldHUSz.ldHUSz.ldHUSz.ldHUSz{height:0;padding-bottom:66.66%;}/*!sc*/ .gbGggw.gbGggw.gbGggw.gbGggw{height:0;padding-bottom:66.25%;}/*!sc*/ .jJPOlH.jJPOlH.jJPOlH.jJPOlH{height:0;padding-bottom:70.3%;}/*!sc*/ .hlekbA.hlekbA.hlekbA.hlekbA{height:0;padding-bottom:77.52%;}/*!sc*/ .gGBgIc.gGBgIc.gGBgIc.gGBgIc{height:0;padding-bottom:52.73%;}/*!sc*/ .cjGBYx.cjGBYx.cjGBYx.cjGBYx{height:0;padding-bottom:67.16%;}/*!sc*/ .iEicaO.iEicaO.iEicaO.iEicaO{height:0;padding-bottom:53.43%;}/*!sc*/ .dwEuyS.dwEuyS.dwEuyS.dwEuyS{height:0;padding-bottom:65.42%;}/*!sc*/ .mZbLn.mZbLn.mZbLn.mZbLn{height:0;padding-bottom:86.06%;}/*!sc*/ .fKsrXE.fKsrXE.fKsrXE.fKsrXE{height:0;padding-bottom:83.33%;}/*!sc*/ .jJDuNs.jJDuNs.jJDuNs.jJDuNs{height:0;padding-bottom:57.5%;}/*!sc*/ .iokUks.iokUks.iokUks.iokUks{height:0;padding-bottom:102.88%;}/*!sc*/ .ezVZoM.ezVZoM.ezVZoM.ezVZoM{height:0;padding-bottom:59.38%;}/*!sc*/ .eZJoHD.eZJoHD.eZJoHD.eZJoHD{height:0;padding-bottom:112.93%;}/*!sc*/ .djHcex.djHcex.djHcex.djHcex{height:0;padding-bottom:95.02%;}/*!sc*/ .dEagds.dEagds.dEagds.dEagds{height:0;padding-bottom:65.62%;}/*!sc*/ .hjCnKb.hjCnKb.hjCnKb.hjCnKb{height:0;padding-bottom:60%;}/*!sc*/ .eetRTf.eetRTf.eetRTf.eetRTf{height:0;padding-bottom:110.44%;}/*!sc*/ .bZIcOd.bZIcOd.bZIcOd.bZIcOd{height:0;padding-bottom:59.06%;}/*!sc*/ .gSabaN.gSabaN.gSabaN.gSabaN{height:0;padding-bottom:111.69%;}/*!sc*/ .ebIGPt.ebIGPt.ebIGPt.ebIGPt{height:0;padding-bottom:52.81%;}/*!sc*/ .bpwXh.bpwXh.bpwXh.bpwXh{height:0;padding-bottom:53.4%;}/*!sc*/ .fdFHmH.fdFHmH.fdFHmH.fdFHmH{height:0;padding-bottom:94.27%;}/*!sc*/ .gzqAYE.gzqAYE.gzqAYE.gzqAYE{height:0;padding-bottom:66.87%;}/*!sc*/ .fUGaTG.fUGaTG.fUGaTG.fUGaTG{height:0;padding-bottom:92.53%;}/*!sc*/ .eIlDNY.eIlDNY.eIlDNY.eIlDNY{height:0;padding-bottom:51.56%;}/*!sc*/ .jUYClY.jUYClY.jUYClY.jUYClY{height:0;padding-bottom:54.06%;}/*!sc*/ .aqCCR.aqCCR.aqCCR.aqCCR{height:0;padding-bottom:52.5%;}/*!sc*/ data-styled.g367[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,fnQDHb,hSeFXV,jAfxuR,eAYXY,kviAry,fJEMj,gmpxUf,bkaZqA,ldHUSz,gbGggw,jJPOlH,hlekbA,gGBgIc,cjGBYx,iEicaO,dwEuyS,mZbLn,fKsrXE,jJDuNs,iokUks,ezVZoM,eZJoHD,djHcex,dEagds,hjCnKb,eetRTf,bZIcOd,gSabaN,ebIGPt,bpwXh,fdFHmH,gzqAYE,fUGaTG,eIlDNY,jUYClY,aqCCR,\"}/*!sc*/ .dfserP.dfserP.dfserP.dfserP{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfserP.dfserP.dfserP.dfserP{font-size:1em!important;}}/*!sc*/ .bWSnVS.bWSnVS.bWSnVS.bWSnVS{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bWSnVS.bWSnVS.bWSnVS.bWSnVS{font-size:1.3em!important;}}/*!sc*/ .kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:1.3em!important;}}/*!sc*/ .dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:1.2em!important;}}/*!sc*/ .jdcGMN.jdcGMN.jdcGMN.jdcGMN{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jdcGMN.jdcGMN.jdcGMN.jdcGMN{font-size:1.4em!important;}}/*!sc*/ .gXQhrg.gXQhrg.gXQhrg.gXQhrg{font-size:7.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gXQhrg.gXQhrg.gXQhrg.gXQhrg{font-size:2.7em!important;}}/*!sc*/ .btuFCM.btuFCM.btuFCM.btuFCM{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.btuFCM.btuFCM.btuFCM.btuFCM{font-size:1.7em!important;}}/*!sc*/ .cGLrSG.cGLrSG.cGLrSG.cGLrSG{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cGLrSG.cGLrSG.cGLrSG.cGLrSG{font-size:1.6em!important;}}/*!sc*/ .jCkLvS.jCkLvS.jCkLvS.jCkLvS{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jCkLvS.jCkLvS.jCkLvS.jCkLvS{font-size:2.6em!important;}}/*!sc*/ .hQxAYP.hQxAYP.hQxAYP.hQxAYP{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.hQxAYP.hQxAYP.hQxAYP.hQxAYP{font-size:2em!important;}}/*!sc*/ .iKalhP.iKalhP.iKalhP.iKalhP{font-size:7.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iKalhP.iKalhP.iKalhP.iKalhP{font-size:2.7em!important;}}/*!sc*/ .fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:1.5em!important;}}/*!sc*/ .fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:1.2em!important;}}/*!sc*/ .bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:1.1em!important;}}/*!sc*/ .eYoKgk.eYoKgk.eYoKgk.eYoKgk{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.eYoKgk.eYoKgk.eYoKgk.eYoKgk{font-size:1.5em!important;}}/*!sc*/ .Uccen.Uccen.Uccen.Uccen{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.Uccen.Uccen.Uccen.Uccen{font-size:1.7em!important;}}/*!sc*/ .gVRWAB.gVRWAB.gVRWAB.gVRWAB{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gVRWAB.gVRWAB.gVRWAB.gVRWAB{font-size:1.5em!important;}}/*!sc*/ .gnnEgw.gnnEgw.gnnEgw.gnnEgw{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gnnEgw.gnnEgw.gnnEgw.gnnEgw{font-size:1.4em!important;}}/*!sc*/ .jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:1.1em!important;}}/*!sc*/ .jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:1.6em!important;}}/*!sc*/ .iEukpb.iEukpb.iEukpb.iEukpb{font-size:8.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iEukpb.iEukpb.iEukpb.iEukpb{font-size:3.1em!important;}}/*!sc*/ .epoJzD.epoJzD.epoJzD.epoJzD{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.epoJzD.epoJzD.epoJzD.epoJzD{font-size:1.1em!important;}}/*!sc*/ .cFtCN.cFtCN.cFtCN.cFtCN{font-size:2.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.cFtCN.cFtCN.cFtCN.cFtCN{font-size:0.7em!important;}}/*!sc*/ .bUEFlv.bUEFlv.bUEFlv.bUEFlv{font-size:1.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bUEFlv.bUEFlv.bUEFlv.bUEFlv{font-size:0.5em!important;}}/*!sc*/ .iNHyie.iNHyie.iNHyie.iNHyie{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.iNHyie.iNHyie.iNHyie.iNHyie{font-size:0.7em!important;}}/*!sc*/ .ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:1.7em!important;}}/*!sc*/ .hXgjw.hXgjw.hXgjw.hXgjw{font-size:9.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.hXgjw.hXgjw.hXgjw.hXgjw{font-size:3.3em!important;}}/*!sc*/ .jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:1.8em!important;}}/*!sc*/ .iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:1.6em!important;}}/*!sc*/ .dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:2.4em!important;}}/*!sc*/ .zWscE.zWscE.zWscE.zWscE{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.zWscE.zWscE.zWscE.zWscE{font-size:0.7em!important;}}/*!sc*/ .dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:0.6em!important;}}/*!sc*/ .cZmotM.cZmotM.cZmotM.cZmotM{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cZmotM.cZmotM.cZmotM.cZmotM{font-size:0.9em!important;}}/*!sc*/ .bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:2em!important;}}/*!sc*/ .eVVsXT.eVVsXT.eVVsXT.eVVsXT{font-size:7.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.eVVsXT.eVVsXT.eVVsXT.eVVsXT{font-size:2.5em!important;}}/*!sc*/ .lplqa-d.lplqa-d.lplqa-d.lplqa-d{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.lplqa-d.lplqa-d.lplqa-d.lplqa-d{font-size:1.2em!important;}}/*!sc*/ .kkHfrE.kkHfrE.kkHfrE.kkHfrE{font-size:8.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kkHfrE.kkHfrE.kkHfrE.kkHfrE{font-size:2.9em!important;}}/*!sc*/ .hrVcDN.hrVcDN.hrVcDN.hrVcDN{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.hrVcDN.hrVcDN.hrVcDN.hrVcDN{font-size:1.7em!important;}}/*!sc*/ .gPIxea.gPIxea.gPIxea.gPIxea{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gPIxea.gPIxea.gPIxea.gPIxea{font-size:1.1em!important;}}/*!sc*/ .bvXqXn.bvXqXn.bvXqXn.bvXqXn{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvXqXn.bvXqXn.bvXqXn.bvXqXn{font-size:1.4em!important;}}/*!sc*/ .gyIQtO.gyIQtO.gyIQtO.gyIQtO{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gyIQtO.gyIQtO.gyIQtO.gyIQtO{font-size:2.7em!important;}}/*!sc*/ .hejuQD.hejuQD.hejuQD.hejuQD{font-size:6.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hejuQD.hejuQD.hejuQD.hejuQD{font-size:2.4em!important;}}/*!sc*/ .cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:1.7em!important;}}/*!sc*/ .kVJNPR.kVJNPR.kVJNPR.kVJNPR{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kVJNPR.kVJNPR.kVJNPR.kVJNPR{font-size:0.8em!important;}}/*!sc*/ .frzFun.frzFun.frzFun.frzFun{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.frzFun.frzFun.frzFun.frzFun{font-size:0.9em!important;}}/*!sc*/ .fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:0.9em!important;}}/*!sc*/ .dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:1.6em!important;}}/*!sc*/ .bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:1.4em!important;}}/*!sc*/ .cvkfBC.cvkfBC.cvkfBC.cvkfBC{font-size:6.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cvkfBC.cvkfBC.cvkfBC.cvkfBC{font-size:2.5em!important;}}/*!sc*/ .lfBuL.lfBuL.lfBuL.lfBuL{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.lfBuL.lfBuL.lfBuL.lfBuL{font-size:1.3em!important;}}/*!sc*/ .iQrIZq.iQrIZq.iQrIZq.iQrIZq{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iQrIZq.iQrIZq.iQrIZq.iQrIZq{font-size:2.2em!important;}}/*!sc*/ .dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:1.9em!important;}}/*!sc*/ .kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:8.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:2.9em!important;}}/*!sc*/ .kNhGgX.kNhGgX.kNhGgX.kNhGgX{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kNhGgX.kNhGgX.kNhGgX.kNhGgX{font-size:1.3em!important;}}/*!sc*/ .eQoVaS.eQoVaS.eQoVaS.eQoVaS{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQoVaS.eQoVaS.eQoVaS.eQoVaS{font-size:2em!important;}}/*!sc*/ .tqGkg.tqGkg.tqGkg.tqGkg{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.tqGkg.tqGkg.tqGkg.tqGkg{font-size:1.9em!important;}}/*!sc*/ .cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:0.8em!important;}}/*!sc*/ .dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:0.6em!important;}}/*!sc*/ .kmfDed.kmfDed.kmfDed.kmfDed{font-size:8.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kmfDed.kmfDed.kmfDed.kmfDed{font-size:3.1em!important;}}/*!sc*/ .lonfPK.lonfPK.lonfPK.lonfPK{font-size:11.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.lonfPK.lonfPK.lonfPK.lonfPK{font-size:4em!important;}}/*!sc*/ .jisCeF.jisCeF.jisCeF.jisCeF{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jisCeF.jisCeF.jisCeF.jisCeF{font-size:1.9em!important;}}/*!sc*/ .kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:0.7em!important;}}/*!sc*/ .blfWBn.blfWBn.blfWBn.blfWBn{font-size:9.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.blfWBn.blfWBn.blfWBn.blfWBn{font-size:3.2em!important;}}/*!sc*/ .jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:6.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:2.4em!important;}}/*!sc*/ .hsPeia.hsPeia.hsPeia.hsPeia{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.hsPeia.hsPeia.hsPeia.hsPeia{font-size:1.4em!important;}}/*!sc*/ .kLBvft.kLBvft.kLBvft.kLBvft{font-size:7.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kLBvft.kLBvft.kLBvft.kLBvft{font-size:2.6em!important;}}/*!sc*/ .jsjrYr.jsjrYr.jsjrYr.jsjrYr{font-size:9.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jsjrYr.jsjrYr.jsjrYr.jsjrYr{font-size:3.4em!important;}}/*!sc*/ .inksEV.inksEV.inksEV.inksEV{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.inksEV.inksEV.inksEV.inksEV{font-size:1.3em!important;}}/*!sc*/ .dJenrE.dJenrE.dJenrE.dJenrE{font-size:6.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.dJenrE.dJenrE.dJenrE.dJenrE{font-size:2.3em!important;}}/*!sc*/ .kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:2.2em!important;}}/*!sc*/ .jPbWVE.jPbWVE.jPbWVE.jPbWVE{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jPbWVE.jPbWVE.jPbWVE.jPbWVE{font-size:1.8em!important;}}/*!sc*/ .bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:1.5em!important;}}/*!sc*/ .bwzwBX.bwzwBX.bwzwBX.bwzwBX{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwzwBX.bwzwBX.bwzwBX.bwzwBX{font-size:1.8em!important;}}/*!sc*/ .bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:1.6em!important;}}/*!sc*/ .ctWqNs.ctWqNs.ctWqNs.ctWqNs{font-size:7em!important;}/*!sc*/ @media only screen and (max-width:640px){.ctWqNs.ctWqNs.ctWqNs.ctWqNs{font-size:2.5em!important;}}/*!sc*/ .kauVAS.kauVAS.kauVAS.kauVAS{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kauVAS.kauVAS.kauVAS.kauVAS{font-size:2.1em!important;}}/*!sc*/ .hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:1.8em!important;}}/*!sc*/ .erpCho.erpCho.erpCho.erpCho{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.erpCho.erpCho.erpCho.erpCho{font-size:1em!important;}}/*!sc*/ .itkiNJ.itkiNJ.itkiNJ.itkiNJ{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.itkiNJ.itkiNJ.itkiNJ.itkiNJ{font-size:0.9em!important;}}/*!sc*/ .beQydf.beQydf.beQydf.beQydf{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.beQydf.beQydf.beQydf.beQydf{font-size:1.7em!important;}}/*!sc*/ .ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:2.9em!important;}}/*!sc*/ .dA-Dohz.dA-Dohz.dA-Dohz.dA-Dohz{font-size:7.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.dA-Dohz.dA-Dohz.dA-Dohz.dA-Dohz{font-size:2.8em!important;}}/*!sc*/ .jfvMWJ.jfvMWJ.jfvMWJ.jfvMWJ{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfvMWJ.jfvMWJ.jfvMWJ.jfvMWJ{font-size:0.9em!important;}}/*!sc*/ .glOqqI.glOqqI.glOqqI.glOqqI{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.glOqqI.glOqqI.glOqqI.glOqqI{font-size:1.4em!important;}}/*!sc*/ .dXa-DVQ.dXa-DVQ.dXa-DVQ.dXa-DVQ{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.dXa-DVQ.dXa-DVQ.dXa-DVQ.dXa-DVQ{font-size:1.1em!important;}}/*!sc*/ .iITVJY.iITVJY.iITVJY.iITVJY{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iITVJY.iITVJY.iITVJY.iITVJY{font-size:1em!important;}}/*!sc*/ .gwDnaT.gwDnaT.gwDnaT.gwDnaT{font-size:7em!important;}/*!sc*/ @media only screen and (max-width:640px){.gwDnaT.gwDnaT.gwDnaT.gwDnaT{font-size:2.6em!important;}}/*!sc*/ .gALHSm.gALHSm.gALHSm.gALHSm{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.gALHSm.gALHSm.gALHSm.gALHSm{font-size:1.9em!important;}}/*!sc*/ .ddbCJZ.ddbCJZ.ddbCJZ.ddbCJZ{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ddbCJZ.ddbCJZ.ddbCJZ.ddbCJZ{font-size:2.1em!important;}}/*!sc*/ .iCwWtY.iCwWtY.iCwWtY.iCwWtY{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iCwWtY.iCwWtY.iCwWtY.iCwWtY{font-size:1.5em!important;}}/*!sc*/ .dLwqhJ.dLwqhJ.dLwqhJ.dLwqhJ{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dLwqhJ.dLwqhJ.dLwqhJ.dLwqhJ{font-size:1.4em!important;}}/*!sc*/ .eQgupK.eQgupK.eQgupK.eQgupK{font-size:8.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQgupK.eQgupK.eQgupK.eQgupK{font-size:3em!important;}}/*!sc*/ .jdgMzU.jdgMzU.jdgMzU.jdgMzU{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jdgMzU.jdgMzU.jdgMzU.jdgMzU{font-size:1em!important;}}/*!sc*/ .gjHDge.gjHDge.gjHDge.gjHDge{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gjHDge.gjHDge.gjHDge.gjHDge{font-size:0.8em!important;}}/*!sc*/ .iAotPC.iAotPC.iAotPC.iAotPC{font-size:8.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iAotPC.iAotPC.iAotPC.iAotPC{font-size:3.2em!important;}}/*!sc*/ .LzBnW.LzBnW.LzBnW.LzBnW{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.LzBnW.LzBnW.LzBnW.LzBnW{font-size:1.5em!important;}}/*!sc*/ .cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:1.5em!important;}}/*!sc*/ .beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:0.6em!important;}}/*!sc*/ .iYgBvA.iYgBvA.iYgBvA.iYgBvA{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.iYgBvA.iYgBvA.iYgBvA.iYgBvA{font-size:0.8em!important;}}/*!sc*/ .iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:1em!important;}}/*!sc*/ data-styled.g368[id=\"x__pt8tzk-0\"]{content:\"dfserP,bWSnVS,kMqJSM,dyaAfc,jdcGMN,gXQhrg,btuFCM,cGLrSG,jCkLvS,hQxAYP,iKalhP,fTAjeM,fIeyCx,bwGQrt,eYoKgk,Uccen,gVRWAB,gnnEgw,jEhvtw,jGSTdz,iEukpb,epoJzD,cFtCN,bUEFlv,iNHyie,ftetSQ,hXgjw,jtCXvA,iXjdLY,dQSCBR,zWscE,dDKeDQ,cZmotM,bxtuZJ,eVVsXT,lplqa-d,kkHfrE,hrVcDN,gPIxea,bvXqXn,gyIQtO,hejuQD,cnjOqe,kVJNPR,frzFun,fNDhDy,dBWQRi,bcCfuJ,cvkfBC,lfBuL,iQrIZq,dfgvpn,kUqUJf,kNhGgX,eQoVaS,tqGkg,cyVXzf,dPoeFo,kmfDed,lonfPK,jisCeF,kwLuaB,blfWBn,jfcAvK,hsPeia,kLBvft,jsjrYr,inksEV,dJenrE,kyzRFP,jPbWVE,bNRoJL,bwzwBX,bkgkdp,ctWqNs,kauVAS,hPDIHE,erpCho,itkiNJ,beQydf,ePuSwO,dA-Dohz,jfvMWJ,glOqqI,dXa-DVQ,iITVJY,gwDnaT,gALHSm,ddbCJZ,iCwWtY,dLwqhJ,eQgupK,jdgMzU,gjHDge,iAotPC,LzBnW,cJcNIn,beDNpZ,iYgBvA,iFlEmK,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div id=\"apos-netboard3\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"AFP-fella: 1,3 mill mindre\" href=\"https://www.dagbladet.no/tema/afp-fella-13-mill-mindre/81275737\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: AFP-fella: 1,3 mill mindre\" alt=\"Image: AFP-fella: 1,3 mill mindre\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81285839&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">AFP-fella: 1,3</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">mill mindre</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Putin raser: - Forrædere\" href=\"https://www.dagbladet.no/video/putin-raser-forraedere/NbWn8lbv\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Putin raser: - Forrædere\" alt=\"Image: Putin raser: - Forrædere\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/NbWn8lbv-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">Putin raser:</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">- Forrædere</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"«Sofa»-pinnedyr gått bort\" href=\"https://www.dagbladet.no/kjendis/sofa-pinnedyr-gatt-bort/81306989\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: «Sofa»-pinnedyr gått bort\" alt=\"Image: «Sofa»-pinnedyr gått bort\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81307011&amp;panow=100&amp;panoy=0&amp;panoh=33.809523809524&amp;panox=0&amp;heightw=61.224489795918&amp;heighty=0&amp;heightx=19.727891156463&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">«Sofa»-pinnedyr</span><span class=\"x__pt8tzk-0 gXQhrg title dynamic-sizing\">gått bort</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Lege reagerer på «diagnose»\" href=\"https://www.dagbladet.no/kjendis/lege-reagerer-pa-diagnose/81305770\"><figure class=\"x__sc-1an7vu1-0 hSeFXV\"><picture><img data-defer=\"view\" title=\"Image: Lege reagerer på «diagnose»\" alt=\"Image: Lege reagerer på «diagnose»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81305846&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=276&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 btuFCM title dynamic-sizing\">Lege reagerer</span><span class=\"x__pt8tzk-0 cGLrSG title dynamic-sizing\">på «diagnose»</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ble drept foran medelever\" href=\"https://www.dagbladet.no/nyheter/ble-drept-foran-medelever/81305476\"><figure class=\"x__sc-1an7vu1-0 jAfxuR\"><picture><img data-defer=\"view\" title=\"Image: Ble drept foran medelever\" alt=\"Image: Ble drept foran medelever\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81305616&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=277&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jCkLvS title dynamic-sizing\">Ble drept</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">foran medelever</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Jeg drakk hver dag\" href=\"https://www.dagbladet.no/sport/jeg-drakk-hver-dag/81296996\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Jeg drakk hver dag\" alt=\"Image: - Jeg drakk hver dag\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81297005&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">- Jeg drakk</span><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">hver dag</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skutt ned nær Finland\" href=\"https://www.dagbladet.no/video/skutt-ned-naer-finland/gv7FLaSE\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Skutt ned nær Finland\" alt=\"Image: Skutt ned nær Finland\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/gv7FLaSE-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">Skutt ned</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">nær Finland</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Pappa-studie: Alarmerende\" href=\"https://www.dagbladet.no/tema/pappa-studie-alarmerende/81303597\"><figure class=\"x__sc-1an7vu1-0 eAYXY\"><picture><img data-defer=\"view\" title=\"Image: Pappa-studie: Alarmerende\" alt=\"Image: Pappa-studie: Alarmerende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81303629&amp;panow=100.10735362319&amp;panoh=50.519584172662&amp;panoy=43.165467625899&amp;panox=0.1073536231884&amp;heighty=0.1524404109589&amp;heightx=35.160229357798&amp;heightw=40.927624770642&amp;heighth=99.467275342466&amp;width=320&amp;height=188&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Pappa-studie:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Alarmerende</span></h3></header></a></article><div id=\"apos-medium-rectangle3\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Spiste sushi: Døde\" href=\"https://www.dagbladet.no/nyheter/spiste-sushi-dode/81300748\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Spiste sushi: Døde\" alt=\"Image: Spiste sushi: Døde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81301038&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">Spiste sushi: Døde</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Raser: - En kniv i ryggen\" href=\"https://www.dagbladet.no/sport/raser-en-kniv-i-ryggen/81305606\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Raser: - En kniv i ryggen\" alt=\"Image: Raser: - En kniv i ryggen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81305634&amp;panox=16.423357664234&amp;panoy=10.989010989011&amp;panow=76.642335766423&amp;panoh=39.010989010989&amp;heightx=35.555555555556&amp;heightw=28.571428571429&amp;heighth=70&amp;heighty=9.047619047619&amp;width=402&amp;height=201&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">Raser: - En</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">kniv i ryggen</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Nå skal hun liksom glemmes\" href=\"https://www.dagbladet.no/nyheter/na-skal-hun-liksom-glemmes/81262400\"><figure class=\"x__sc-1an7vu1-0 fJEMj\"><picture><img data-defer=\"view\" title=\"Image: - Nå skal hun liksom glemmes\" alt=\"Image: - Nå skal hun liksom glemmes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81268311&amp;panoy=17.796610169492&amp;panox=0&amp;panow=100&amp;panoh=60.169491525424&amp;heighty=0&amp;heightw=34.48275862069&amp;heighth=100&amp;heightx=30.268199233716&amp;width=402&amp;height=370&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gnnEgw title dynamic-sizing\">- Nå skal hun</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">liksom glemmes</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russisk minister pågrepet\" href=\"https://www.dagbladet.no/nyheter/russisk-minister-pagrepet/81306733\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Russisk minister pågrepet\" alt=\"Image: Russisk minister pågrepet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81306736&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">Russisk minister</span><span class=\"x__pt8tzk-0 iEukpb title dynamic-sizing\">pågrepet</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Navalnyj: Nye opplysninger ryster\" href=\"https://www.dagbladet.no/video/navalnyj-nye-opplysninger-ryster/JHLyQU30\"><figure class=\"x__sc-1an7vu1-0 gmpxUf\"><picture><img data-defer=\"view\" title=\"Image: Navalnyj: Nye opplysninger ryster\" alt=\"Image: Navalnyj: Nye opplysninger ryster\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/JHLyQU30-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Navalnyj: Nye</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">opplysninger ryster</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skattetipset eldre glemmer: - Betydelige summer\" href=\"https://www.dagbladet.no/tema/skattetipset-eldre-glemmer-betydelige-summer/81287267\"><figure class=\"x__sc-1an7vu1-0 gmpxUf\"><picture><img data-defer=\"view\" title=\"Image: Skattetipset eldre glemmer: - Betydelige summer\" alt=\"Image: Skattetipset eldre glemmer: - Betydelige summer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81287629&amp;panoy=14.893617021277&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heighty=0.22371409395974&amp;heightx=32.735426008969&amp;width=320&amp;height=178&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bUEFlv title dynamic-sizing\">Skattetipset eldre glemmer:</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">- Betydelige summer</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"NRK-program slaktes\" href=\"https://www.dagbladet.no/kjendis/nrk-program-slaktes/81287698\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: NRK-program slaktes\" alt=\"Image: NRK-program slaktes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81285330&amp;panow=100&amp;panoh=22.539682539683&amp;panoy=14.920634920635&amp;panox=0&amp;heighty=7.4235807860262&amp;heightx=23.17880794702&amp;heightw=59.602649006623&amp;heighth=64.192139737991&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">NRK-program</span><span class=\"x__pt8tzk-0 hXgjw title dynamic-sizing\">slaktes</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Superstjerna overrasket alle\" href=\"https://www.dagbladet.no/kjendis/superstjerna-overrasket-alle/81300592\"><figure class=\"x__sc-1an7vu1-0 bkaZqA\"><picture><img data-defer=\"view\" title=\"Image: Superstjerna overrasket alle\" alt=\"Image: Superstjerna overrasket alle\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81300664&amp;panow=34.305780551053&amp;panoh=15.762834273319&amp;panoy=28.416485900217&amp;panox=54.943273905997&amp;heighty=14.965986394558&amp;heightx=57.179487179487&amp;heightw=23.504273333333&amp;heighth=50.566893197279&amp;width=485&amp;height=312&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Superstjerna</span><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">overrasket alle</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Omkommet\" href=\"https://www.dagbladet.no/nyheter/omkommet/81306045\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Omkommet\" alt=\"Image: Omkommet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81306050&amp;panoy=20.338983050847&amp;panox=0&amp;panow=100&amp;panoh=60.169491525424&amp;heighty=0&amp;heightw=34.48275862069&amp;heighth=100&amp;heightx=37.164750957854&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dQSCBR title dynamic-sizing\">Omkommet</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Pornokonge avslørt:- Perverst\" href=\"https://www.dagbladet.no/nyheter/pornokonge-avslort-perverst/81297991\"><figure class=\"x__sc-1an7vu1-0 ldHUSz\"><picture><img data-defer=\"view\" title=\"Image: Pornokonge avslørt:- Perverst\" alt=\"Image: Pornokonge avslørt:- Perverst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81300632&amp;panoy=0&amp;panox=0&amp;panow=93.945127719962&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=93.945127719962&amp;heighth=100&amp;width=402&amp;height=268&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">Pornokonge</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">avslørt:- Perverst</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advokat: Styr unna framtidsfullmakt-fella \" href=\"https://www.dagbladet.no/tema/advokat-styr-unna-framtidsfullmakt-fella/81077382\"><figure class=\"x__sc-1an7vu1-0 gbGggw\"><picture><img data-defer=\"view\" title=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" alt=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81242728&amp;panoy=16.551724137931&amp;panox=0.083402752293575&amp;panow=100.08340275229&amp;panoh=51.159874482759&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=320&amp;height=212&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Advokat: Styr unna</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">framtidsfullmakt-fella </span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fansen i sjokk: - Vulgært\" href=\"https://www.dagbladet.no/video/fansen-i-sjokk-vulgaert/Mme1xJhi\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Fansen i sjokk: - Vulgært\" alt=\"Image: Fansen i sjokk: - Vulgært\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Mme1xJhi-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">Fansen i sjokk:</span><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">- Vulgært</span></h3></header></a></article><div id=\"apos-medium-rectangle-perz3\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle-perz3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle-perz3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Første gang på 139 år\" href=\"https://www.dagbladet.no/sport/forste-gang-pa-139-ar/81297176\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Første gang på 139 år\" alt=\"Image: Første gang på 139 år\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81297182&amp;panoy=5.0359712230216&amp;panox=0.16025673076923&amp;panow=100.16025673077&amp;panoh=51.318945323741&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">Første gang</span><span class=\"x__pt8tzk-0 eVVsXT title dynamic-sizing\">på 139 år</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Raser mot TVNorge: - Hadde muligheten\" href=\"https://www.dagbladet.no/kjendis/raser-mot-tvnorge-hadde-muligheten/81302917\"><figure class=\"x__sc-1an7vu1-0 jJPOlH\"><picture><img data-defer=\"view\" title=\"Image: Raser mot TVNorge: - Hadde muligheten\" alt=\"Image: Raser mot TVNorge: - Hadde muligheten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81303232&amp;panoy=0&amp;panox=0.15151545454546&amp;panow=99.848484545455&amp;panoh=56.997454961832&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=341&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Raser mot TVNorge:</span><span class=\"x__pt8tzk-0 lplqa-d title dynamic-sizing\">- Hadde muligheten</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nekter å svare\" href=\"https://www.dagbladet.no/nyheter/nekter-a-svare/81305776\"><figure class=\"x__sc-1an7vu1-0 hlekbA\"><picture><img data-defer=\"view\" title=\"Image: Nekter å svare\" alt=\"Image: Nekter å svare\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81305815&amp;panoy=8.3832335329341&amp;panox=8&amp;panow=84&amp;panoh=42.51497005988&amp;heightx=20.883534136546&amp;heightw=36.144578313253&amp;heighth=88.55421686747&amp;heighty=6.0240963855422&amp;width=485&amp;height=376&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">Nekter å svare</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ryktene svirrer: Raser\" href=\"https://www.dagbladet.no/sport/ryktene-svirrer-raser/81302290\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ryktene svirrer: Raser\" alt=\"Image: Ryktene svirrer: Raser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302578&amp;panow=78.947368421053&amp;panoh=38.378378378378&amp;panox=9.3984962406015&amp;panoy=16.216216216216&amp;heighty=0&amp;heightx=27.488151658768&amp;heightw=42.654028436019&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kkHfrE title dynamic-sizing\">Ryktene</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">svirrer: Raser</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard5\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Linn (33) fikk sjokkbeskjed: Advarer\" href=\"https://www.dagbladet.no/tema/linn-33-fikk-sjokkbeskjed-advarer/81263652\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Linn (33) fikk sjokkbeskjed: Advarer\" alt=\"Image: Linn (33) fikk sjokkbeskjed: Advarer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302345&amp;panox=33.333333333333&amp;panow=29.518835042735&amp;panoh=66.878306666667&amp;panoy=18.095238095238&amp;heighty=0.15325655172413&amp;heightx=45.407098121086&amp;heightw=9.31338434238&amp;heighth=100.15325655172&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Linn (33) fikk</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">sjokkbeskjed: Advarer</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Genialt om sluket er tett\" href=\"https://www.dagbladet.no/video/genialt-om-sluket-er-tett/foYBohdb\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Genialt om sluket er tett\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/78411518.jpg?imageId=78411518&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/02/03/ae920136-73af-4f5a-9d17-621bcd91dd9a/gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/02/03/ae920136-73af-4f5a-9d17-621bcd91dd9a/gif_1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bvXqXn title dynamic-sizing\">Genialt om</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">sluket er tett</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sier stopp\" href=\"https://www.dagbladet.no/sport/sier-stopp/81300733\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Sier stopp\" alt=\"Image: Sier stopp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81300769&amp;panox=0&amp;panoy=8.4507042253521&amp;panow=100&amp;panoh=50&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gyIQtO title dynamic-sizing\">Sier stopp</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kunne bli rasende\" href=\"https://www.dagbladet.no/sport/kunne-bli-rasende/81303298\"><figure class=\"x__sc-1an7vu1-0 gGBgIc\"><picture><img data-defer=\"view\" title=\"Image: - Kunne bli rasende\" alt=\"Image: - Kunne bli rasende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81303384&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=17.142857142857&amp;panox=0&amp;heighty=0&amp;heightx=32.126696832579&amp;heightw=40.723981900452&amp;heighth=100&amp;width=402&amp;height=212&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hejuQD title dynamic-sizing\">- Kunne</span><span class=\"x__pt8tzk-0 cnjOqe title dynamic-sizing\">bli rasende</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russiske «double tap»-angrep: - Brutalt\" href=\"https://www.dagbladet.no/nyheter/russiske-double-tap-angrep-brutalt/81274328\"><figure class=\"x__sc-1an7vu1-0 cjGBYx\"><picture><img data-defer=\"view\" title=\"Image: Russiske «double tap»-angrep: - Brutalt\" alt=\"Image: Russiske «double tap»-angrep: - Brutalt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81281128&amp;panoy=7.8571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=270&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Russiske «double</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">tap»-angrep: - Brutalt</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ikke kjærester\" href=\"https://www.dagbladet.no/kjendis/ikke-kjaerester/81301665\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Ikke kjærester\" alt=\"Image: - Ikke kjærester\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81301746&amp;panow=99.842766981132&amp;panoy=19.182389937107&amp;panox=0&amp;panoh=22.851152830189&amp;heighty=0&amp;heightx=7.4074080808081&amp;heightw=92.592591919192&amp;heighth=99.77628590604&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">- Ikke kjærester</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sissel: Ett grep - 10 kilo forsvant!\" href=\"https://www.dagbladet.no/tema/sissel-ett-grep-10-kilo-forsvant/81152733\"><figure class=\"x__sc-1an7vu1-0 iEicaO\"><picture><img data-defer=\"view\" title=\"Image: Sissel: Ett grep - 10 kilo forsvant!\" alt=\"Image: Sissel: Ett grep - 10 kilo forsvant!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81155820&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=171&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">Sissel: Ett grep -</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">10 kilo forsvant!</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Lover Ukraina 50 hver måned\" href=\"https://www.dagbladet.no/video/lover-ukraina-50-hver-maned/ggYF0q3p\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Lover Ukraina 50 hver måned\" alt=\"Image: Lover Ukraina 50 hver måned\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/ggYF0q3p-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Lover Ukraina</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">50 hver måned</span></h3></header></a></article><div id=\"apos-medium-rectangle-perz4\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle-perz4\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle-perz4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Trekkes inn i ny skandale\" href=\"https://www.dagbladet.no/sport/trekkes-inn-i-ny-skandale/81300939\"><figure class=\"x__sc-1an7vu1-0 dwEuyS\"><picture><img data-defer=\"view\" title=\"Image: Trekkes inn i ny skandale\" alt=\"Image: Trekkes inn i ny skandale\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80212989&amp;panox=0&amp;panow=100&amp;panoh=53.383458646617&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=263&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">Trekkes inn</span><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">i ny skandale</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Et signal\" href=\"https://www.dagbladet.no/kjendis/et-signal/81286995\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Et signal\" alt=\"Image: - Et signal\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81287025&amp;panoy=1.3422818791946&amp;panox=2.2222222222222&amp;panow=94.074073777778&amp;panoh=48.769574496644&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">- Et signal</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Forventer at USA blir\" href=\"https://www.dagbladet.no/nyheter/forventer-at-usa-blir/81305555\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Forventer at USA blir\" alt=\"Image: - Forventer at USA blir\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81305569&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=5&amp;panox=0&amp;heighty=0&amp;heightx=30.316742081448&amp;heightw=40.723981900452&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cvkfBC title dynamic-sizing\">- Forventer</span><span class=\"x__pt8tzk-0 jCkLvS title dynamic-sizing\">at USA blir</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kan resultere i fengsel\" href=\"https://www.dagbladet.no/nyheter/kan-resultere-i-fengsel/81305059\"><figure class=\"x__sc-1an7vu1-0 mZbLn\"><picture><img data-defer=\"view\" title=\"Image: - Kan resultere i fengsel\" alt=\"Image: - Kan resultere i fengsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81299937&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;heightw=100&amp;width=402&amp;height=346&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 lfBuL title dynamic-sizing\">- Kan resultere</span><span class=\"x__pt8tzk-0 iQrIZq title dynamic-sizing\">i fengsel</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-smartbanner2\" class=\"adunit-wrapper columns small-12 medium-12 large-12 track-element  \" data-from=\"xavier\"><div id=\"ad-smartbanner2\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600],[980,300],[970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;smartbanner2&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Angrep på  europeisk demokrati\" href=\"https://www.dagbladet.no/nyheter/angrep-pa-europeisk-demokrati/81302781\"><figure class=\"x__sc-1an7vu1-0 bkaZqA\"><picture><img data-defer=\"view\" title=\"Image: - Angrep på  europeisk demokrati\" alt=\"Image: - Angrep på  europeisk demokrati\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302789&amp;panoy=13.571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightx=40.27149321267&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=312&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">- Angrep på </span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">europeisk demokrati</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nådeløs dom: - Fiasko\" href=\"https://www.dagbladet.no/sport/nadelos-dom-fiasko/81305029\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Nådeløs dom: - Fiasko\" alt=\"Image: Nådeløs dom: - Fiasko\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81305047&amp;panox=0&amp;panow=100&amp;panoh=23.745819397993&amp;panoy=25.083612040134&amp;heighty=26.769911504425&amp;heightx=27.619047619048&amp;heightw=28.571428571429&amp;heighth=32.522123893805&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">Nådeløs dom:</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">- Fiasko</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"I sorg: - Hadde indre demoner\" href=\"https://www.dagbladet.no/kjendis/i-sorg-hadde-indre-demoner/81298717\"><figure class=\"x__sc-1an7vu1-0 fKsrXE\"><picture><img data-defer=\"view\" title=\"Image: I sorg: - Hadde indre demoner\" alt=\"Image: I sorg: - Hadde indre demoner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302495&amp;panoy=18.702290076336&amp;panox=0&amp;panow=100&amp;panoh=27.099236641221&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=335&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">I sorg: - Hadde</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">indre demoner</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Barna hadde noen spørsmål\" href=\"https://www.dagbladet.no/nyheter/barna-hadde-noen-sporsmal/81305924\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Barna hadde noen spørsmål\" alt=\"Image: - Barna hadde noen spørsmål\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81306016&amp;panoy=28.571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightx=14.932126696833&amp;heightw=40.723981900452&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eQoVaS title dynamic-sizing\">- Barna hadde</span><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">noen spørsmål</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"«Pappa har skrevet noe dumt»\" href=\"https://www.dagbladet.no/tema/snakker-ut-om-whisky-innleggene/81251334\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: «Pappa har skrevet noe dumt»\" alt=\"Image: «Pappa har skrevet noe dumt»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81251351&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">«Pappa har</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">skrevet noe dumt»</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Brutale kamper: - Mistet flere brigader\" href=\"https://www.dagbladet.no/video/brutale-kamper-mistet-flere-brigader/kAkEx7tx\"><figure class=\"x__sc-1an7vu1-0 jJDuNs\"><picture><img data-defer=\"view\" title=\"Image: Brutale kamper: - Mistet flere brigader\" alt=\"Image: Brutale kamper: - Mistet flere brigader\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kAkEx7tx-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Brutale kamper:</span><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">- Mistet flere brigader</span></h3></header></a></article><div id=\"apos-medium-rectangle4\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle4\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Tungt å stå i\" href=\"https://www.dagbladet.no/nyheter/tungt-a-sta-i/81304378\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Tungt å stå i\" alt=\"Image: - Tungt å stå i\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81304948&amp;panow=100&amp;panoh=46.103896103896&amp;panoy=11.688311688312&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kmfDed title dynamic-sizing\">- Tungt</span><span class=\"x__pt8tzk-0 lonfPK title dynamic-sizing\">å stå i</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vil ha lukkede dører\" href=\"https://www.dagbladet.no/nyheter/vil-ha-lukkede-dorer/81300594\"><figure class=\"x__sc-1an7vu1-0 iokUks\"><picture><img data-defer=\"view\" title=\"Image: Vil ha lukkede dører\" alt=\"Image: Vil ha lukkede dører\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81300610&amp;panox=0&amp;panow=100&amp;panoh=51.094890510949&amp;panoy=2.9197080291971&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=499&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Vil ha lukkede dører</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Soldater forsøplet vidda: - Sjokkert\" href=\"https://www.dagbladet.no/nyheter/soldater-forsoplet-vidda-sjokkert/81301398\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Soldater forsøplet vidda: - Sjokkert\" alt=\"Image: Soldater forsøplet vidda: - Sjokkert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81301439&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">Soldater forsøplet</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">vidda: - Sjokkert</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Catch and kill\" href=\"https://www.dagbladet.no/meninger/catch-and-kill/81301305\"><figure class=\"x__sc-1an7vu1-0 ezVZoM\"><picture><img data-defer=\"view\" title=\"Image: Catch and kill\" alt=\"Image: Catch and kill\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81299918&amp;panoy=14.48275862069&amp;panox=0&amp;panow=100&amp;panoh=51.034482758621&amp;heightw=40.869565217391&amp;heighth=100&amp;heighty=0&amp;heightx=26.086956521739&amp;width=485&amp;height=288&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">Catch and kill</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard6\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Utrolig resultat\" href=\"https://www.dagbladet.no/video/utrolig-resultat/j2D0QJvD\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Utrolig resultat\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/77658621.jpg?imageId=77658621&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/11/04/0000d0f4-5a91-436b-80a2-98e6e2a76865/gif_stekeovn_4.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/11/04/0000d0f4-5a91-436b-80a2-98e6e2a76865/gif_stekeovn_4.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iQrIZq title dynamic-sizing\">Utrolig</span><span class=\"x__pt8tzk-0 jisCeF title dynamic-sizing\">resultat</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ny astmamedisin: 70 prosent færre anfall\" href=\"https://www.dagbladet.no/tema/ny-astmamedisin70-prosent-faerre-anfall/81108717\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ny astmamedisin: 70 prosent færre anfall\" alt=\"Image: Ny astmamedisin: 70 prosent færre anfall\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81141573&amp;panox=0.18957345971564&amp;panow=100.18957345972&amp;panoh=47.94701986755&amp;panoy=13.907284768212&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Ny astmamedisin: 70</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">prosent færre anfall</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Det ble noen tårer\" href=\"https://www.dagbladet.no/sport/det-ble-noen-tarer/81295977\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Det ble noen tårer\" alt=\"Image: - Det ble noen tårer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302410&amp;panox=14.248021108179&amp;panow=55.408970976253&amp;panoh=28.174603174603&amp;panoy=11.111111111111&amp;heighth=100&amp;heighty=0&amp;heightx=19.004524886878&amp;heightw=40.723981900452&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 blfWBn title dynamic-sizing\">- Det ble</span><span class=\"x__pt8tzk-0 gyIQtO title dynamic-sizing\">noen tårer</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dutty Diors kjæreste bryter tausheten\" href=\"https://www.dagbladet.no/kjendis/dutty-diors-kjaereste-bryter-tausheten/81302913\"><figure class=\"x__sc-1an7vu1-0 eZJoHD\"><picture><img data-defer=\"view\" title=\"Image: Dutty Diors kjæreste bryter tausheten\" alt=\"Image: Dutty Diors kjæreste bryter tausheten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302927&amp;panox=0&amp;panow=99.842766981132&amp;panoh=51.173708450704&amp;panoy=11.971830985915&amp;heightw=41.291290990991&amp;heighth=99.77628590604&amp;heighty=0&amp;heightx=18.918918918919&amp;width=402&amp;height=454&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Dutty Diors kjæreste</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">bryter tausheten</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"50 471 i Putins graver\" href=\"https://www.dagbladet.no/nyheter/50-471-i-putins-graver/81191630\"><figure class=\"x__sc-1an7vu1-0 djHcex\"><picture><img data-defer=\"view\" title=\"Image: 50 471 i Putins graver\" alt=\"Image: 50 471 i Putins graver\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81262597&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=382&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfcAvK title dynamic-sizing\">50 471 i</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">Putins graver</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dramatisk gjensyn\" href=\"https://www.dagbladet.no/meninger/dramatisk-gjensyn/81304634\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dramatisk gjensyn\" alt=\"Image: Dramatisk gjensyn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81304872&amp;panow=100.19047619048&amp;panoh=48.590604026846&amp;panoy=20.134228187919&amp;panox=0.19047619047619&amp;heighty=0.27210884353742&amp;heightx=16.267942583732&amp;heightw=43.253588516746&amp;heighth=100.27210884354&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kLBvft title dynamic-sizing\">Dramatisk</span><span class=\"x__pt8tzk-0 jsjrYr title dynamic-sizing\">gjensyn</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tesla-feil: - Livsfarlig\" href=\"https://www.dagbladet.no/video/-livsfarlig/FWV0OCuM\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Tesla-feil: - Livsfarlig\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81296499.jpg?imageId=81296499&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/22/68b28de4-2520-4bce-bf78-86584804a8e8/tesla.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/22/68b28de4-2520-4bce-bf78-86584804a8e8/tesla.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gnnEgw title dynamic-sizing\">Tesla-feil:</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">- Livsfarlig</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fellene: Banken spiser pensjonen\" href=\"https://www.dagbladet.no/tema/fellene-banken-spiser-pensjonen/81173450\"><figure class=\"x__sc-1an7vu1-0 dEagds\"><picture><img data-defer=\"view\" title=\"Image: Fellene: Banken spiser pensjonen\" alt=\"Image: Fellene: Banken spiser pensjonen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81153720&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=320&amp;height=210&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Fellene: Banken</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">spiser pensjonen</span></h3></header></a></article><div id=\"apos-medium-rectangle5\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle5\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Prisen for et halvt liv\" href=\"https://www.dagbladet.no/meninger/prisen-for-et-halvt-liv/81298385\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Prisen for et halvt liv\" alt=\"Image: Prisen for et halvt liv\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80585408&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dJenrE title dynamic-sizing\">Prisen for</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">et halvt liv</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer etter tannlege-tabbe\" href=\"https://www.dagbladet.no/nyheter/advarer-etter-tannlege-tabbe/81304051\"><figure class=\"x__sc-1an7vu1-0 hjCnKb\"><picture><img data-defer=\"view\" title=\"Image: Advarer etter tannlege-tabbe\" alt=\"Image: Advarer etter tannlege-tabbe\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81304816&amp;panox=0&amp;panow=100&amp;panoh=63.963963963964&amp;panoy=0&amp;heighty=0&amp;heightx=44.086021505376&amp;heightw=32.258064516129&amp;heighth=100&amp;width=485&amp;height=291&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jPbWVE title dynamic-sizing\">Advarer etter</span><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">tannlege-tabbe</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Aldri sett henne sånn\" href=\"https://www.dagbladet.no/kjendis/aldri-sett-henne-sann/81301797\"><figure class=\"x__sc-1an7vu1-0 eetRTf\"><picture><img data-defer=\"view\" title=\"Image: - Aldri sett henne sånn\" alt=\"Image: - Aldri sett henne sånn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81301958&amp;panoy=9.9290780141844&amp;panox=0&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heighth=99.77628590604&amp;heighty=0&amp;heightx=22.869955156951&amp;heightw=41.106128251121&amp;width=402&amp;height=444&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">- Aldri sett</span><span class=\"x__pt8tzk-0 bkgkdp title dynamic-sizing\">henne sånn</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Siktet etter våpenfunn: - Ubehagelig\" href=\"https://www.dagbladet.no/nyheter/siktet-etter-vapenfunn-ubehagelig/81297767\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Siktet etter våpenfunn: - Ubehagelig\" alt=\"Image: Siktet etter våpenfunn: - Ubehagelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81297812&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cvkfBC title dynamic-sizing\">Siktet etter</span><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">våpenfunn:</span><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">- Ubehagelig</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard7\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Enormt sjokk: Knust av sorg\" href=\"https://www.dagbladet.no/kjendis/enormt-sjokk-knust-av-sorg/80982170\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Enormt sjokk: Knust av sorg\" alt=\"Image: Enormt sjokk: Knust av sorg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80982182&amp;panow=84&amp;panoh=42.51497005988&amp;panoy=5.3892215568862&amp;panox=7.6&amp;heighty=0&amp;heightx=27.07423580786&amp;heightw=41.048034934498&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Enormt sjokk:</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Knust av sorg</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skistads oppførsel skaper raseri\" href=\"https://www.dagbladet.no/video/skistads-oppforsel-skaper-raseri/tKqBZUwJ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Skistads oppførsel skaper raseri\" alt=\"Image: Skistads oppførsel skaper raseri\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/tKqBZUwJ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Skistads oppførsel</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">skaper raseri</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skal ha truet ansatte og skutt radiator\" href=\"https://www.dagbladet.no/nyheter/skal-ha-truet-ansatte-og-skutt-radiator/81302150\"><figure class=\"x__sc-1an7vu1-0 ezVZoM\"><picture><img data-defer=\"view\" title=\"Image: Skal ha truet ansatte og skutt radiator\" alt=\"Image: Skal ha truet ansatte og skutt radiator\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302261&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=288&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Skal ha truet ansatte</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">og skutt radiator</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sensasjonelt streng straff\" href=\"https://www.dagbladet.no/meninger/sensasjonelt-streng-straff/81303580\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Sensasjonelt streng straff\" alt=\"Image: Sensasjonelt streng straff\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81215233&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">Sensasjonelt</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">streng straff</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Leverer maten - så rømmer den\" href=\"https://www.dagbladet.no/video/svermer-ut/DNXpmYCc\"><figure class=\"x__sc-1an7vu1-0 bZIcOd moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Leverer maten - så rømmer den\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81299930.jpg?imageId=81299930&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=189\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/09/13/fb429644-d7b3-4614-aaf7-f81634692d75/gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/09/13/fb429644-d7b3-4614-aaf7-f81634692d75/gif_1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 erpCho title dynamic-sizing\">Leverer maten</span><span class=\"x__pt8tzk-0 itkiNJ title dynamic-sizing\">- så rømmer den</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/avslorer-alvorlig-sykdom/81230494\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Avslører alvorlig sykdom\" alt=\"Image: Avslører alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81240727&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=17.277486910995&amp;heightw=32.514619649123&amp;heighth=78.359510994764&amp;heightx=14.736842105263&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 beQydf title dynamic-sizing\">Avslører</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">alvorlig sykdom</span></h3></header></a></article><div id=\"apos-medium-rectangle6\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle6\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sven Erik (42) drept\" href=\"https://www.dagbladet.no/nyheter/sven-erik-42-drept/81305050\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Sven Erik (42) drept\" alt=\"Image: Sven Erik (42) drept\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81305072&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ePuSwO title dynamic-sizing\">Sven Erik</span><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">(42) drept</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ødegaard herjet i storseier mot Chelsea\" href=\"https://www.dagbladet.no/sport/odegaard-herjet-i-storseier-mot-chelsea/81306087\"><figure class=\"x__sc-1an7vu1-0 gSabaN\"><picture><img data-defer=\"view\" title=\"Image: Ødegaard herjet i storseier mot Chelsea\" alt=\"Image: Ødegaard herjet i storseier mot Chelsea\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81306116&amp;panoh=51.079136690647&amp;panoy=15.827338129496&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=20.27027027027&amp;heightw=40.540540540541&amp;heighth=100&amp;width=402&amp;height=449&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Ødegaard herjet i</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">storseier mot Chelsea</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard8\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tegnene: Slim i halsen er sykdom\" href=\"https://www.dagbladet.no/tema/slim-i-halsen-kan-avslore-sykdom/81013182\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Tegnene: Slim i halsen er sykdom\" alt=\"Image: Tegnene: Slim i halsen er sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81090927&amp;panoy=0&amp;panow=100.10735362319&amp;panoh=50.885668115942&amp;panox=0&amp;heighty=0.15325655172413&amp;heightx=34.862385321101&amp;heightw=40.927624770642&amp;heighth=100.15325655172&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Tegnene: Slim i</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">halsen er sykdom</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dukket opp naken på jobb\" href=\"https://www.dagbladet.no/video/dukket-opp-naken-pa-jobb/7M8Rspms\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Dukket opp naken på jobb\" alt=\"Image: Dukket opp naken på jobb\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/7M8Rspms-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Dukket opp</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">naken på jobb</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Jagerflyet går i lufta\" href=\"https://www.dagbladet.no/video/jagerflyet-gar-i-lufta/qocxhxds\"><figure class=\"x__sc-1an7vu1-0 ebIGPt\"><picture><img data-defer=\"view\" title=\"Image: Jagerflyet går i lufta\" alt=\"Image: Jagerflyet går i lufta\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/qocxhxds-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 glOqqI title dynamic-sizing\">Jagerflyet</span><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">går i lufta</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarsel om neglesopp: Kan være sykdom\" href=\"https://www.dagbladet.no/tema/advarsel-om-neglesopp-kan-vaere-sykdom/81083345\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advarsel om neglesopp: Kan være sykdom\" alt=\"Image: Advarsel om neglesopp: Kan være sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81090086&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dXa-DVQ title dynamic-sizing\">Advarsel om</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">neglesopp: Kan</span><span class=\"x__pt8tzk-0 iITVJY title dynamic-sizing\">være sykdom</span></h3></header></a></article><div id=\"apos-medium-rectangle7\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle7\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Fant på mye idiotisk\" href=\"https://www.dagbladet.no/nyheter/fant-pa-mye-idiotisk/81304472\"><figure class=\"x__sc-1an7vu1-0 bpwXh\"><picture><img data-defer=\"view\" title=\"Image: - Fant på mye idiotisk\" alt=\"Image: - Fant på mye idiotisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81304548&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=259&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gwDnaT title dynamic-sizing\">- Fant på</span><span class=\"x__pt8tzk-0 gALHSm title dynamic-sizing\">mye idiotisk</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russelåt skaper reaksjoner: - Tatt det til oss\" href=\"https://www.dagbladet.no/nyheter/russelat-skaper-reaksjoner-tatt-det-til-oss/81288590\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Russelåt skaper reaksjoner: - Tatt det til oss\" alt=\"Image: Russelåt skaper reaksjoner: - Tatt det til oss\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81297761&amp;panoy=10.569105691057&amp;panox=0&amp;panow=100&amp;panoh=60.162601626016&amp;heightw=34.558823529412&amp;heighth=100&amp;heighty=0&amp;heightx=49.632352941176&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">Russelåt skaper</span><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">reaksjoner:</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- Tatt det til oss</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ufør? Ekstragodene få vet om\" href=\"https://www.dagbladet.no/tema/ufor-ekstragodene-fa-vet-om-1/81118437\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ufør? Ekstragodene få vet om\" alt=\"Image: Ufør? Ekstragodene få vet om\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81127308&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Ufør? Ekstragodene</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">få vet om</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russerne stjeler svensk våpen - angrer\" href=\"https://www.dagbladet.no/video/russerne-stjeler-svensk-vapen-angrer/GBzaqmRd\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russerne stjeler svensk våpen - angrer\" alt=\"Image: Russerne stjeler svensk våpen - angrer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/GBzaqmRd-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Russerne stjeler</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">svensk våpen - angrer</span></h3></header></a></article></div></div><div id=\"apos-netboard9\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard9\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Familien fikk feil levninger\" href=\"https://www.dagbladet.no/nyheter/familien-fikk-feil-levninger/81301761\"><figure class=\"x__sc-1an7vu1-0 fdFHmH\"><picture><img data-defer=\"view\" title=\"Image: Familien fikk feil levninger\" alt=\"Image: Familien fikk feil levninger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81301765&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=379&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iCwWtY title dynamic-sizing\">Familien fikk</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">feil levninger</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slo ned som ei bombe\" href=\"https://www.dagbladet.no/sport/slo-ned-som-ei-bombe/81296834\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Slo ned som ei bombe\" alt=\"Image: Slo ned som ei bombe\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81297747&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">Slo ned som</span><span class=\"x__pt8tzk-0 eQgupK title dynamic-sizing\">ei bombe</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Her avskjæres russerne\" href=\"https://www.dagbladet.no/video/her-avskjaeres-russerne/uH793H8Q\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Her avskjæres russerne\" alt=\"Image: Her avskjæres russerne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uH793H8Q-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Her avskjæres</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">russerne</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Psykolog: - Vanligste årsaken til brudd\" href=\"https://www.dagbladet.no/tema/psykolog-vanligste-arsaken-til-brudd/81091739\"><figure class=\"x__sc-1an7vu1-0 gzqAYE\"><picture><img data-defer=\"view\" title=\"Image: Psykolog: - Vanligste årsaken til brudd\" alt=\"Image: Psykolog: - Vanligste årsaken til brudd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80505690&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=214&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Psykolog: - Vanligste</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">årsaken til brudd</span></h3></header></a></article><div id=\"apos-medium-rectangle8\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Omstridt lovforslag vedtatt\" href=\"https://www.dagbladet.no/nyheter/omstridt-lovforslag-vedtatt/81301450\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Omstridt lovforslag vedtatt\" alt=\"Image: Omstridt lovforslag vedtatt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81301457&amp;panoy=0&amp;panox=10.069444444444&amp;panow=73.263888888889&amp;panoh=72&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iAotPC title dynamic-sizing\">Omstridt</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">lovforslag vedtatt</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Etterforskes som drapsforsøk\" href=\"https://www.dagbladet.no/nyheter/etterforskes-som-drapsforsok/81302136\"><figure class=\"x__sc-1an7vu1-0 fUGaTG\"><picture><img data-defer=\"view\" title=\"Image: Etterforskes som drapsforsøk\" alt=\"Image: Etterforskes som drapsforsøk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302207&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=372&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cJcNIn title dynamic-sizing\">Etterforskes</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">som drapsforsøk</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard10\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard10\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ukjent ADHD-variant: Særlig kvinner rammes\" href=\"https://www.dagbladet.no/tema/ukjent-adhd-variant-saerlig-kvinner-rammes/81247654\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ukjent ADHD-variant: Særlig kvinner rammes\" alt=\"Image: Ukjent ADHD-variant: Særlig kvinner rammes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81247819&amp;panoy=36.193029490617&amp;panox=0&amp;panow=100&amp;panoh=19.034852546917&amp;heightw=63.829787234043&amp;heighth=59.036144578313&amp;heighty=25.70281124498&amp;heightx=19.148936170213&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Ukjent ADHD-variant:</span><span class=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Særlig kvinner rammes</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Reagerer: - Voldsom\" href=\"https://www.dagbladet.no/video/reagerer-voldsom/v2blPJ8V\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Voldsom\" alt=\"Image: Reagerer: - Voldsom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/v2blPJ8V-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cJcNIn title dynamic-sizing\">Reagerer:</span><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">- Voldsom</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Innrømmer «juks» i NRK-program\" href=\"https://www.dagbladet.no/video/innrommer-juks-i-nrk-program/lMkzrfpg\"><figure class=\"x__sc-1an7vu1-0 eIlDNY\"><picture><img data-defer=\"view\" title=\"Image: Innrømmer «juks» i NRK-program\" alt=\"Image: Innrømmer «juks» i NRK-program\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/lMkzrfpg-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Innrømmer «juks»</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">i NRK-program</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fibromyalgi: Smertefri uten medisiner\" href=\"https://www.dagbladet.no/tema/meretes-fibromyalgi-grep-smertefri/81302351\"><figure class=\"x__sc-1an7vu1-0 jUYClY\"><picture><img data-defer=\"view\" title=\"Image: Fibromyalgi: Smertefri uten medisiner\" alt=\"Image: Fibromyalgi: Smertefri uten medisiner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81153547&amp;panoy=18.181818181818&amp;panox=3.781512605042&amp;panow=86.274512605042&amp;panoh=21.010103030303&amp;heightw=38.136829694323&amp;heighth=45.21556466877&amp;heighty=10.725552050473&amp;heightx=29.257641921397&amp;width=320&amp;height=173&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Fibromyalgi: Smertefri</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">uten medisiner</span></h3></header></a></article><div id=\"apos-medium-rectangle9\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard11\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Supergrepet: Annette (52) raste ned i vekt\" href=\"https://www.dagbladet.no/tema/supergrepet-annette-52-raste-ned-i-vekt/81173683\"><figure class=\"x__sc-1an7vu1-0 aqCCR\"><picture><img data-defer=\"view\" title=\"Image: Supergrepet: Annette (52) raste ned i vekt\" alt=\"Image: Supergrepet: Annette (52) raste ned i vekt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81183655&amp;panoy=0&amp;panow=97.757847533632&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=40.217391304348&amp;heightw=20.434782608696&amp;heighth=100&amp;width=320&amp;height=168&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Supergrepet: Annette</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">(52) raste ned i vekt</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dukket plutselig opp i bryllupet\" href=\"https://www.dagbladet.no/video/overrasker-else-under-bryllupet/rIwkxk9M\"><figure class=\"x__sc-1an7vu1-0 aqCCR moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Dukket plutselig opp i bryllupet\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81298406.jpg?imageId=81298406&amp;x=0.000000&amp;y=9.057971&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=168\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/22/67872de2-c232-4ed5-8081-43362d3a4755/gif2_-_ramona.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/22/67872de2-c232-4ed5-8081-43362d3a4755/gif2_-_ramona.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 itkiNJ title dynamic-sizing\">Dukket plutselig</span><span class=\"x__pt8tzk-0 erpCho title dynamic-sizing\">opp i bryllupet</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Angrep dypt inne i Russland\" href=\"https://www.dagbladet.no/video/angrep-dypt-inne-i-russland/QQaMwbw0\"><figure class=\"x__sc-1an7vu1-0 jJDuNs\"><picture><img data-defer=\"view\" title=\"Image: Angrep dypt inne i Russland\" alt=\"Image: Angrep dypt inne i Russland\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/QQaMwbw0-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Angrep dypt</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">inne i Russland</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"«Amanda» var utro: Unnskyldningene hun serverte \" href=\"https://www.dagbladet.no/tema/amanda-var-utro-unnskyldningene-hun-serverte/81149452\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: «Amanda» var utro: Unnskyldningene hun serverte \" alt=\"Image: «Amanda» var utro: Unnskyldningene hun serverte \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81160005&amp;panoy=13.138686131387&amp;panox=0&amp;panow=99.759615384615&amp;panoh=51.459854014599&amp;heighty=0.3448275862069&amp;heightw=40.227272727273&amp;heighth=100.34482758621&amp;heightx=15.909090909091&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">«Amanda» var utro:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Unnskyldningene</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">hun serverte </span></h3></header></a></article><div id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Utestengt på livstid etter dette\" href=\"https://www.dagbladet.no/video/utestengt-pa-livstid-etter-dette/JjRyUcQh\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Utestengt på livstid etter dette\" alt=\"Image: Utestengt på livstid etter dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/JjRyUcQh-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Utestengt på</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">livstid etter dette</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nye turkjøkken: Billigste slår alle!\" href=\"https://www.dagbladet.no/tema/nye-turkjokken-det-billigste-slar-alle/81119606\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Nye turkjøkken: Billigste slår alle!\" alt=\"Image: Nye turkjøkken: Billigste slår alle!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81173377&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Nye turkjøkken:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Billigste slår alle!</span></h3></header></a></article></div></div><div id=\"apos-netboard12\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard12&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Barna får panikk etter dette\" href=\"https://www.dagbladet.no/video/familien-vitner-kampen-skriker/iBoUJYa5\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Barna får panikk etter dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81301581.jpg?imageId=81301581&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/22/a54e8619-2ac7-4ff6-af1b-1cf586a2ca5d/gif1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/22/a54e8619-2ac7-4ff6-af1b-1cf586a2ca5d/gif1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 itkiNJ title dynamic-sizing\">Barna får panikk</span><span class=\"x__pt8tzk-0 gnnEgw title dynamic-sizing\">etter dette</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tinnitus: Da får du uføretrygd\" href=\"https://www.dagbladet.no/tema/tinnitus-da-far-du-uforetrygd/81107069\"><figure class=\"x__sc-1an7vu1-0 gmpxUf\"><picture><img data-defer=\"view\" title=\"Image: Tinnitus: Da får du uføretrygd\" alt=\"Image: Tinnitus: Da får du uføretrygd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=79375708&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0.24155072463768&amp;heightw=40.544875&amp;heighth=100.24155072464&amp;heightx=38.461538461538&amp;width=320&amp;height=178&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Tinnitus: Da får</span><span class=\"x__pt8tzk-0 iITVJY title dynamic-sizing\">du uføretrygd</span></h3></header></a></article><div id=\"apos-medium-rectangle11\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle11\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div>"]