-
Melding om slagsmål
-
Moxnes ønsker nye år på Stortinget
-
Fire døde da reklameskilt kollapset
-
Nabokonflikt i Bergen: Kvinne kuttet med kniv
-
Arbeidsulykke på Mongstad: Mann til sykehus
-
Nasrallah vil la syriske flyktninger ta sjøveien fra Libanon til Europa
-
FN-ansatt drept i angrep mot nødhjelpskolonne i Gaza
-
Stryn: Mann i 30-åra savnet
-
Stor terrengbrann i Øygarden er slukket
-
NRK: Sp-nestor Marit Arnstad gir seg på Stortinget
Magefett-formelen:Borte på 10 uker
Utsettes for rasisme- slår tilbake
Annonsørinnhold
Meskerkokken har énviktig grill-regel
i samarbeid med
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
AKKURAT NÅ:
STØRRE SLAGSMÅL:
40 russebiler på stedet
NYE BILDER:
- Aldri sett før
Bryter ut full panikk
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
SVALBARD-SALGET:
Ekspert: Verdien overdrives
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
MANN TIL SYKEHUS:
Forgiftet av motorsag
Deler gladnyhet
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
KJEMPEHULL:
På størrelse med Belgia
DNA-FUNN:
Blankt avvist
["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .gxpIRV.gxpIRV.gxpIRV.gxpIRV{height:0;padding-bottom:55.46%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .ldkMOS.ldkMOS.ldkMOS.ldkMOS{height:0;padding-bottom:51.54%;}/*!sc*/ .bzUfFP.bzUfFP.bzUfFP.bzUfFP{height:0;padding-bottom:75%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .kvbyOp.kvbyOp.kvbyOp.kvbyOp{height:0;padding-bottom:75.37%;}/*!sc*/ .cbpmkX.cbpmkX.cbpmkX.cbpmkX{height:0;padding-bottom:121.64%;}/*!sc*/ .gQoIpx.gQoIpx.gQoIpx.gQoIpx{height:0;padding-bottom:69.27%;}/*!sc*/ .hNWIcE.hNWIcE.hNWIcE.hNWIcE{height:0;padding-bottom:73.38%;}/*!sc*/ .bZIcOd.bZIcOd.bZIcOd.bZIcOd{height:0;padding-bottom:59.06%;}/*!sc*/ .gmpxUf.gmpxUf.gmpxUf.gmpxUf{height:0;padding-bottom:55.62%;}/*!sc*/ .iYLNuD.iYLNuD.iYLNuD.iYLNuD{height:0;padding-bottom:56.7%;}/*!sc*/ .VvExd.VvExd.VvExd.VvExd{height:0;padding-bottom:61.23%;}/*!sc*/ .evCJJb.evCJJb.evCJJb.evCJJb{height:0;padding-bottom:92.78%;}/*!sc*/ .imatiz.imatiz.imatiz.imatiz{height:0;padding-bottom:77.11%;}/*!sc*/ .bEAsVD.bEAsVD.bEAsVD.bEAsVD{height:0;padding-bottom:61.25%;}/*!sc*/ .coZoQh.coZoQh.coZoQh.coZoQh{height:0;padding-bottom:76.61%;}/*!sc*/ .cTplBD.cTplBD.cTplBD.cTplBD{height:0;padding-bottom:55.22%;}/*!sc*/ .epIDcn.epIDcn.epIDcn.epIDcn{height:0;padding-bottom:63.09%;}/*!sc*/ .hRlocb.hRlocb.hRlocb.hRlocb{height:0;padding-bottom:57.46%;}/*!sc*/ .FvIbz.FvIbz.FvIbz.FvIbz{height:0;padding-bottom:64.06%;}/*!sc*/ .iEicaO.iEicaO.iEicaO.iEicaO{height:0;padding-bottom:53.43%;}/*!sc*/ .clfoyJ.clfoyJ.clfoyJ.clfoyJ{height:0;padding-bottom:68.04%;}/*!sc*/ .cQSpuk.cQSpuk.cQSpuk.cQSpuk{height:0;padding-bottom:52.37%;}/*!sc*/ .dUaGqQ.dUaGqQ.dUaGqQ.dUaGqQ{height:0;padding-bottom:64.67%;}/*!sc*/ .evezpr.evezpr.evezpr.evezpr{height:0;padding-bottom:64.42%;}/*!sc*/ .iQmtHL.iQmtHL.iQmtHL.iQmtHL{height:0;padding-bottom:56.56%;}/*!sc*/ .iRrFGC.iRrFGC.iRrFGC.iRrFGC{height:0;padding-bottom:54.37%;}/*!sc*/ .jjcUMQ.jjcUMQ.jjcUMQ.jjcUMQ{height:0;padding-bottom:58.35%;}/*!sc*/ .dYPbEE.dYPbEE.dYPbEE.dYPbEE{height:0;padding-bottom:80.34%;}/*!sc*/ .ioOUcG.ioOUcG.ioOUcG.ioOUcG{height:0;padding-bottom:60.61%;}/*!sc*/ .dZwFXb.dZwFXb.dZwFXb.dZwFXb{height:0;padding-bottom:56.87%;}/*!sc*/ .hPMFKU.hPMFKU.hPMFKU.hPMFKU{height:0;padding-bottom:86.81%;}/*!sc*/ .kAAGbU.kAAGbU.kAAGbU.kAAGbU{height:0;padding-bottom:57.18%;}/*!sc*/ .hjJzLP.hjJzLP.hjJzLP.hjJzLP{height:0;padding-bottom:67.5%;}/*!sc*/ .kbQZSd.kbQZSd.kbQZSd.kbQZSd{height:0;padding-bottom:71.95%;}/*!sc*/ .iGqPLB.iGqPLB.iGqPLB.iGqPLB{height:0;padding-bottom:80%;}/*!sc*/ .gUTrxt.gUTrxt.gUTrxt.gUTrxt{height:0;padding-bottom:50.74%;}/*!sc*/ .ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .iPjCRj.iPjCRj.iPjCRj.iPjCRj{height:0;padding-bottom:68.75%;}/*!sc*/ .eAYXY.eAYXY.eAYXY.eAYXY{height:0;padding-bottom:58.75%;}/*!sc*/ data-styled.g367[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,gxpIRV,fnQDHb,ldkMOS,bzUfFP,kviAry,kvbyOp,cbpmkX,gQoIpx,hNWIcE,bZIcOd,gmpxUf,iYLNuD,VvExd,evCJJb,imatiz,bEAsVD,coZoQh,cTplBD,epIDcn,hRlocb,FvIbz,iEicaO,clfoyJ,cQSpuk,dUaGqQ,evezpr,iQmtHL,iRrFGC,jjcUMQ,dYPbEE,ioOUcG,dZwFXb,hPMFKU,kAAGbU,hjJzLP,kbQZSd,iGqPLB,gUTrxt,ejnyBo,iPjCRj,eAYXY,\"}/*!sc*/ .jwrbOd.jwrbOd.jwrbOd.jwrbOd{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.jwrbOd.jwrbOd.jwrbOd.jwrbOd{font-size:1.9em!important;}}/*!sc*/ .eEpMqg.eEpMqg.eEpMqg.eEpMqg{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.eEpMqg.eEpMqg.eEpMqg.eEpMqg{font-size:2.3em!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*/ .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*/ .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*/ .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*/ .dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:2em!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*/ .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*/ .jPnLUB.jPnLUB.jPnLUB.jPnLUB{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jPnLUB.jPnLUB.jPnLUB.jPnLUB{font-size:2.3em!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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:0.5em!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*/ .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*/ .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*/ .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*/ .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*/ .ijicdz.ijicdz.ijicdz.ijicdz{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ijicdz.ijicdz.ijicdz.ijicdz{font-size:1em!important;}}/*!sc*/ .gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:1.8em!important;}}/*!sc*/ .iAWFly.iAWFly.iAWFly.iAWFly{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iAWFly.iAWFly.iAWFly.iAWFly{font-size:2.2em!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*/ .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*/ .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*/ .jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:2.1em!important;}}/*!sc*/ .ZTWfd.ZTWfd.ZTWfd.ZTWfd{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.ZTWfd.ZTWfd.ZTWfd.ZTWfd{font-size:2.5em!important;}}/*!sc*/ .fjKRAi.fjKRAi.fjKRAi.fjKRAi{font-size:1.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fjKRAi.fjKRAi.fjKRAi.fjKRAi{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*/ .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*/ .fFAiTK.fFAiTK.fFAiTK.fFAiTK{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.fFAiTK.fFAiTK.fFAiTK.fFAiTK{font-size:1.9em!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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .wpWLG.wpWLG.wpWLG.wpWLG{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.wpWLG.wpWLG.wpWLG.wpWLG{font-size:1.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*/ .emaxbb.emaxbb.emaxbb.emaxbb{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.emaxbb.emaxbb.emaxbb.emaxbb{font-size:1.7em!important;}}/*!sc*/ .hIOHzH.hIOHzH.hIOHzH.hIOHzH{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.hIOHzH.hIOHzH.hIOHzH.hIOHzH{font-size:2.3em!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*/ .kxzaKl.kxzaKl.kxzaKl.kxzaKl{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.kxzaKl.kxzaKl.kxzaKl.kxzaKl{font-size:1em!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*/ .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*/ .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*/ .jiGVVj.jiGVVj.jiGVVj.jiGVVj{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.jiGVVj.jiGVVj.jiGVVj.jiGVVj{font-size:1.2em!important;}}/*!sc*/ .ggUSon.ggUSon.ggUSon.ggUSon{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.ggUSon.ggUSon.ggUSon.ggUSon{font-size:0.6em!important;}}/*!sc*/ .bXDgwp.bXDgwp.bXDgwp.bXDgwp{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bXDgwp.bXDgwp.bXDgwp.bXDgwp{font-size:2.2em!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*/ .gLHLEv.gLHLEv.gLHLEv.gLHLEv{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gLHLEv.gLHLEv.gLHLEv.gLHLEv{font-size:1.1em!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*/ .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*/ .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*/ .eElPMU.eElPMU.eElPMU.eElPMU{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.eElPMU.eElPMU.eElPMU.eElPMU{font-size:3em!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*/ .iVreMl.iVreMl.iVreMl.iVreMl{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.iVreMl.iVreMl.iVreMl.iVreMl{font-size:1.6em!important;}}/*!sc*/ .eVBoHG.eVBoHG.eVBoHG.eVBoHG{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.eVBoHG.eVBoHG.eVBoHG.eVBoHG{font-size:0.9em!important;}}/*!sc*/ .inoUtg.inoUtg.inoUtg.inoUtg{font-size:8.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.inoUtg.inoUtg.inoUtg.inoUtg{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*/ .hbwikt.hbwikt.hbwikt.hbwikt{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.hbwikt.hbwikt.hbwikt.hbwikt{font-size:2.1em!important;}}/*!sc*/ .jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:1.3em!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*/ .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*/ .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*/ .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*/ .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*/ .ivnriz.ivnriz.ivnriz.ivnriz{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ivnriz.ivnriz.ivnriz.ivnriz{font-size:1.2em!important;}}/*!sc*/ data-styled.g368[id=\"x__pt8tzk-0\"]{content:\"jwrbOd,eEpMqg,cyVXzf,frzFun,jtCXvA,jdgMzU,dWzMnA,eYoKgk,dJenrE,kyzRFP,jPnLUB,ddbCJZ,kVJNPR,iYgBvA,tqGkg,kMqJSM,jGSTdz,gPIxea,iFlEmK,hXgjw,dfserP,bWSnVS,hrVcDN,ctWqNs,kNhGgX,dfgvpn,cFtCN,jRIgeY,dDKeDQ,gjHDge,bwzwBX,gVRWAB,LzBnW,ijicdz,gWsWwS,iAWFly,itkiNJ,jdcGMN,fNDhDy,jJrnNf,ZTWfd,fjKRAi,cZmotM,Uccen,fFAiTK,ftetSQ,dyaAfc,bcCfuJ,dA-Dohz,hQxAYP,jfvMWJ,zWscE,jfcAvK,lplqa-d,wpWLG,iKalhP,emaxbb,hIOHzH,bNRoJL,kxzaKl,gyIQtO,dBWQRi,inksEV,jiGVVj,ggUSon,bXDgwp,hsPeia,gLHLEv,gXQhrg,bxtuZJ,kwLuaB,eElPMU,bvXqXn,iVreMl,eVBoHG,inoUtg,epoJzD,hbwikt,jIyTDK,fIeyCx,iITVJY,cGLrSG,iNHyie,bwGQrt,ivnriz,\"}/*!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 bg-blue\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kan ta flåtten\" href=\"https://www.dagbladet.no/video/trikset-fjerner-blodsugeren/fJ9NBSkh\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: - Kan ta flåtten\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/79238072.jpg?imageId=79238072&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/05/08/17665adb-4f36-4240-b21c-69a6b88372ba/flatt_gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/05/08/17665adb-4f36-4240-b21c-69a6b88372ba/flatt_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 jwrbOd title dynamic-sizing\">- Kan ta</span><span class=\"x__pt8tzk-0 eEpMqg title dynamic-sizing\">flåtten</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=\"Sjøgrens: Ta disse tegnene på alvor\" href=\"https://www.dagbladet.no/tema/sjogrens-ta-disse-tegnene-pa-alvor/81333224\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Sjøgrens: Ta disse tegnene på alvor\" alt=\"Image: Sjøgrens: Ta disse tegnene på alvor\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342634&amp;panoy=20.567375886525&amp;panox=0&amp;panow=100&amp;panoh=49.645390070922&amp;heightw=42.105263157895&amp;heighth=100&amp;heightx=30.143540669856&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 cyVXzf title dynamic-sizing\">Sjøgrens: Ta disse</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">tegnene på alvor</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=\"Tolv døde da reklameskilt kollapset\" href=\"https://www.dagbladet.no/nyheter/tolv-dode-da-reklameskilt-kollapset/81398605\"><figure class=\"x__sc-1an7vu1-0 gxpIRV\"><picture><img data-defer=\"view\" title=\"Image: Tolv døde da reklameskilt kollapset\" alt=\"Image: Tolv døde da reklameskilt kollapset\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398614&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=269&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\">Tolv døde da</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">reklameskilt kollapset</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=\"Ny beskjed: Har mistet evne\" href=\"https://www.dagbladet.no/kjendis/ny-beskjed-har-mistet-evne/81396782\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ny beskjed: Har mistet evne\" alt=\"Image: Ny beskjed: Har mistet evne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396790&amp;panox=0&amp;panoy=3.1746031746032&amp;panow=100&amp;panoh=22.539682539683&amp;heightw=100&amp;heighty=0&amp;heighth=100&amp;heightx=0&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 dWzMnA title dynamic-sizing\">Ny beskjed:</span><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">Har mistet evne</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=\"Hudfletter Eurovision\" href=\"https://www.dagbladet.no/kjendis/hudfletter-eurovision/81393157\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Hudfletter Eurovision\" alt=\"Image: Hudfletter Eurovision\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81394057&amp;panoy=11.347517730496&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panox=0.15723301886793&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 dJenrE title dynamic-sizing\">Hudfletter</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">Eurovision</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=\"NRK-glipp på direkten\" href=\"https://www.dagbladet.no/kjendis/nrk-glipp-pa-direkten/81389648\"><figure class=\"x__sc-1an7vu1-0 ldkMOS\"><picture><img data-defer=\"view\" title=\"Image: NRK-glipp på direkten\" alt=\"Image: NRK-glipp på direkten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81391305&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=250&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 jPnLUB title dynamic-sizing\">NRK-glipp</span><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">på direkten</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=\"Madelens formel: Fra 0 til millionær!\" href=\"https://www.dagbladet.no/tema/madelens-formel-fra-0-til-millionaer/81382473\"><figure class=\"x__sc-1an7vu1-0 bzUfFP\"><picture><img data-defer=\"view\" title=\"Image: Madelens formel: Fra 0 til millionær!\" alt=\"Image: Madelens formel: Fra 0 til millionær!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81382730&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=240&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 kVJNPR title dynamic-sizing\">Madelens formel:</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Fra 0 til millionær!</span></h3></header></a></article><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=\"Avviser reporteren\" href=\"https://www.dagbladet.no/video/presses-nekter-a-svare/UdlLnshP\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Avviser reporteren\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81392887.jpg?imageId=81392887&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/05/07/fea006f7-ddc9-4a98-96b4-825b0ebd740b/gif_skistad_svar.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/07/fea006f7-ddc9-4a98-96b4-825b0ebd740b/gif_skistad_svar.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 tqGkg title dynamic-sizing\">Avviser</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">reporteren</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=\"Raser mot rykter\" href=\"https://www.dagbladet.no/sport/raser-mot-rykter/81377329\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Raser mot rykter\" alt=\"Image: Raser mot rykter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81377352&amp;panox=0&amp;panow=100&amp;panoh=54.615384615385&amp;panoy=6.1538461538462&amp;heightx=32.773109243697&amp;heighty=0&amp;heightw=37.81512605042&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\">Raser mot rykter</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=\"Røper: - Et sjokk\" href=\"https://www.dagbladet.no/kjendis/roper-et-sjokk/81356540\"><figure class=\"x__sc-1an7vu1-0 kvbyOp\"><picture><img data-defer=\"view\" title=\"Image: Røper: - Et sjokk\" alt=\"Image: Røper: - Et sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81354774&amp;panoy=5.3020134228188&amp;panow=100&amp;panoh=37.51677852349&amp;panox=0&amp;heighty=5.3020134228188&amp;heightx=0&amp;heightw=100&amp;heighth=37.51677852349&amp;width=402&amp;height=303&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 gPIxea title dynamic-sizing\">Røper: - Et sjokk</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=\"Ferdig etterforsket\" href=\"https://www.dagbladet.no/kjendis/ferdig-etterforsket/81396293\"><figure class=\"x__sc-1an7vu1-0 cbpmkX\"><picture><img data-defer=\"view\" title=\"Image: Ferdig etterforsket\" alt=\"Image: Ferdig etterforsket\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396298&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=402&amp;height=489&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 iFlEmK title dynamic-sizing\">Ferdig etterforsket</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=\"Tidenes beste finale\" href=\"https://www.dagbladet.no/meninger/tidenes-beste-finale/81394022\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Tidenes beste finale\" alt=\"Image: Tidenes beste finale\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81390343&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=54.751131221719&amp;heightw=40.904977375566&amp;heighth=100.27210884354&amp;heighty=0.27210884353742&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 hXgjw title dynamic-sizing\">Tidenes</span><span class=\"x__pt8tzk-0 dJenrE title dynamic-sizing\">beste finale</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=\"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=\"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 iFlEmK title dynamic-sizing\">50 hver måned</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=\"Vekker avsky\" href=\"https://www.dagbladet.no/sport/vekker-avsky/81397607\"><figure class=\"x__sc-1an7vu1-0 gQoIpx\"><picture><img data-defer=\"view\" title=\"Image: Vekker avsky\" alt=\"Image: Vekker avsky\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81397611&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=336&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 hrVcDN title dynamic-sizing\">Vekker avsky</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=\"Bekrefter endring i planene\" href=\"https://www.dagbladet.no/sport/bekrefter-endring-i-planene/81396120\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter endring i planene\" alt=\"Image: Bekrefter endring i planene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396158&amp;panoy=2.4390243902439&amp;panox=20.12987012987&amp;panow=68.181818181818&amp;panoh=34.634146341463&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 ctWqNs title dynamic-sizing\">Bekrefter</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">endring i planene</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=\"54 år gammelt mysterium løst\" href=\"https://www.dagbladet.no/nyheter/54-ar-gammelt-mysterium-lost/81360323\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: 54 år gammelt mysterium løst\" alt=\"Image: 54 år gammelt mysterium løst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81362489&amp;panoy=20.491803278689&amp;panox=5.1724137931034&amp;panow=91.235631896552&amp;panoh=59.562840983607&amp;heightw=22.802653233831&amp;heighth=70.125785849057&amp;heighty=14.150943396226&amp;heightx=69.651741293532&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 dfgvpn title dynamic-sizing\">54 år gammelt</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">mysterium løst</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=\"- Skal ikke bli misbrukt\" href=\"https://www.dagbladet.no/kjendis/skal-ikke-bli-misbrukt/81383817\"><figure class=\"x__sc-1an7vu1-0 hNWIcE\"><picture><img data-defer=\"view\" title=\"Image: - Skal ikke bli misbrukt\" alt=\"Image: - Skal ikke bli misbrukt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81383708&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;heightx=31.221719457014&amp;width=402&amp;height=295&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\">- Skal ikke</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">bli misbrukt</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=\"Helene ned 30 kilo: Oppsiktsvekkende metode\" href=\"https://www.dagbladet.no/tema/helene-ned-30-kilo-oppsiktsvekkende-metode/81287177\"><figure class=\"x__sc-1an7vu1-0 bZIcOd\"><picture><img data-defer=\"view\" title=\"Image: Helene ned 30 kilo: Oppsiktsvekkende metode\" alt=\"Image: Helene ned 30 kilo: Oppsiktsvekkende metode\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81287397&amp;panoy=0.31298591549295&amp;panox=0&amp;panow=98.017737089202&amp;panoh=99.687014084507&amp;heightx=38.584474885845&amp;heightw=20.497210045662&amp;heighth=99.847794520548&amp;heighty=0&amp;width=320&amp;height=189&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\">Helene ned 30 kilo:</span><span class=\"x__pt8tzk-0 jRIgeY title dynamic-sizing\">Oppsiktsvekkende metode</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=\"Ukrainsk missilangrep: - Over 100 drept\" href=\"https://www.dagbladet.no/video/ukrainsk-missilangrep-over-100-drept/wWGsrDHF\"><figure class=\"x__sc-1an7vu1-0 gmpxUf\"><picture><img data-defer=\"view\" title=\"Image: Ukrainsk missilangrep: - Over 100 drept\" alt=\"Image: Ukrainsk missilangrep: - Over 100 drept\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/wWGsrDHF-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 dDKeDQ title dynamic-sizing\">Ukrainsk missilangrep:</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">- Over 100 drept</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øler meg veldig sårbar\" href=\"https://www.dagbladet.no/kjendis/foler-meg-veldig-sarbar/81387305\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Føler meg veldig sårbar\" alt=\"Image: - Føler meg veldig sårbar\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81387347&amp;panoy=18.560606060606&amp;panow=100&amp;panoh=27.272727272727&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 dWzMnA title dynamic-sizing\">- Føler meg</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">veldig sårbar</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=\"Bannlyst i deler av egen delstat\" href=\"https://www.dagbladet.no/nyheter/bannlyst-i-deler-av-egen-delstat/81398817\"><figure class=\"x__sc-1an7vu1-0 iYLNuD\"><picture><img data-defer=\"view\" title=\"Image: Bannlyst i deler av egen delstat\" alt=\"Image: Bannlyst i deler av egen delstat\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398848&amp;panox=10.31746031746&amp;panow=83.730158730159&amp;panoh=42.857142857143&amp;panoy=8.3333333333333&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=275&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 gVRWAB title dynamic-sizing\">Bannlyst i deler</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">av egen delstat</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><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=\"Om angsten: - Trodde jeg skulle dø\" href=\"https://www.dagbladet.no/kjendis/om-angsten-trodde-jeg-skulle-do/81174480\"><figure class=\"x__sc-1an7vu1-0 VvExd\"><picture><img data-defer=\"view\" title=\"Image: Om angsten: - Trodde jeg skulle dø\" alt=\"Image: Om angsten: - Trodde jeg skulle dø\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81179534&amp;panoy=7.0422535211268&amp;panox=0&amp;panow=100&amp;panoh=50&amp;heightw=41.666666666667&amp;heighth=100&amp;heighty=0&amp;heightx=23.364485981308&amp;width=485&amp;height=297&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 ijicdz title dynamic-sizing\">Om angsten: - Trodde</span><span class=\"x__pt8tzk-0 gWsWwS title dynamic-sizing\">jeg skulle dø</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=\"- Håper det ordner seg\" href=\"https://www.dagbladet.no/kjendis/haper-det-ordner-seg/81397445\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Håper det ordner seg\" alt=\"Image: - Håper det ordner seg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81397453&amp;panoy=10.859728506787&amp;panox=10.877192982456&amp;panow=74.335839298246&amp;panoh=16.483516289593&amp;heightw=36.451246825397&amp;heighth=38.168497948718&amp;heighty=6.9230769230769&amp;heightx=31.746031746032&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 ddbCJZ title dynamic-sizing\">- Håper det</span><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">ordner seg</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 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=\"Eliteserie-mål går verden rundt\" href=\"https://www.dagbladet.no/video/eliteserie-mal-ryster-fotballverdenen/BYTIot20\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Eliteserie-mål går verden rundt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81381627.jpg?imageId=81381627&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/05/08/974e1a8d-788f-4fde-8641-857516dfe1f2/gif_bendtner1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/08/974e1a8d-788f-4fde-8641-857516dfe1f2/gif_bendtner1.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 ijicdz title dynamic-sizing\">Eliteserie-mål</span><span class=\"x__pt8tzk-0 itkiNJ title dynamic-sizing\">går verden rundt</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 metode stoppet alkosug\" href=\"https://www.dagbladet.no/tema/charlotta-48-kvitt-alkosuget/81180198\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ny metode stoppet alkosug\" alt=\"Image: Ny metode stoppet alkosug\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81182843&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 jdcGMN title dynamic-sizing\">Ny metode</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">stoppet alkosug</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7 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=\"«Festet vilt»: Reiste ikke\" href=\"https://www.dagbladet.no/kjendis/festet-vilt-reiste-ikke/81391398\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: «Festet vilt»: Reiste ikke\" alt=\"Image: «Festet vilt»: Reiste ikke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81391445&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=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 jJrnNf title dynamic-sizing\">«Festet vilt»:</span><span class=\"x__pt8tzk-0 ZTWfd title dynamic-sizing\">Reiste ikke</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=\"MC-fører døde etter politijakt\" href=\"https://www.dagbladet.no/nyheter/mc-forer-dode-etter-politijakt/81397692\"><figure class=\"x__sc-1an7vu1-0 evCJJb\"><picture><img data-defer=\"view\" title=\"Image: MC-fører døde etter politijakt\" alt=\"Image: MC-fører døde etter politijakt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81397823&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=373&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\">MC-fører døde</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">etter politijakt</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=\"Norovirus-utbrudd på sykehus\" href=\"https://www.dagbladet.no/nyheter/norovirus-utbrudd-pa-sykehus/81397645\"><figure class=\"x__sc-1an7vu1-0 imatiz\"><picture><img data-defer=\"view\" title=\"Image: Norovirus-utbrudd på sykehus\" alt=\"Image: Norovirus-utbrudd på sykehus\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81397660&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=402&amp;height=310&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 iFlEmK title dynamic-sizing\">Norovirus-utbrudd</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">på sykehus</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=\"Trekker seg som forskningsleder\" href=\"https://www.dagbladet.no/nyheter/trekker-seg-som-forskningsleder/81395928\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Trekker seg som forskningsleder\" alt=\"Image: Trekker seg som forskningsleder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396066&amp;panox=24.113475177305&amp;panow=74.468085106383&amp;panoh=43.827160493827&amp;panoy=16.666666666667&amp;heightw=30.100334448161&amp;heighth=85.964912280702&amp;heighty=1.7543859649123&amp;heightx=45.484949832776&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\">Trekker seg som</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">forskningsleder</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=\"Erikas «overgangsalder» var alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/erikas-overgangsalder-var-alvorlig-sykdom/81329162\"><figure class=\"x__sc-1an7vu1-0 bEAsVD\"><picture><img data-defer=\"view\" title=\"Image: Erikas «overgangsalder» var alvorlig sykdom\" alt=\"Image: Erikas «overgangsalder» var alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81263672&amp;panoy=18.64406779661&amp;panox=24.418604651163&amp;panow=60.562015697674&amp;panoh=60.451977966102&amp;heightx=39.333333333333&amp;heightw=29.777778&amp;heighth=79.099099459459&amp;heighty=18.918918918919&amp;width=320&amp;height=196&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 fjKRAi title dynamic-sizing\">Erikas «overgangsalder»</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">var alvorlig sykdom</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=\"Israel: Bryter sammen i tårer\" href=\"https://www.dagbladet.no/video/israel-bryter-sammen-i-tarer/Y9q6sNWC\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Israel: Bryter sammen i tårer\" alt=\"Image: Israel: Bryter sammen i tårer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Y9q6sNWC-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 gPIxea title dynamic-sizing\">Israel: Bryter</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">sammen i tårer</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=\"- Skolen er tilpasset jenter\" href=\"https://www.dagbladet.no/nyheter/skolen-er-tilpasset-jenter/81372374\"><figure class=\"x__sc-1an7vu1-0 coZoQh\"><picture><img data-defer=\"view\" title=\"Image: - Skolen er tilpasset jenter\" alt=\"Image: - Skolen er tilpasset jenter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81383955&amp;panoy=12.837837837838&amp;panow=99.848484545455&amp;panoh=50.45045&amp;panox=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=402&amp;height=308&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\">- Skolen er</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">tilpasset jenter</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=\"Cohen klar for å avsløre Trump\" href=\"https://www.dagbladet.no/nyheter/cohen-klar-for-a-avslore-trump/81395847\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Cohen klar for å avsløre Trump\" alt=\"Image: Cohen klar for å avsløre Trump\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396008&amp;panox=0&amp;panow=100&amp;panoh=54.615384615385&amp;panoy=26.153846153846&amp;heighty=0&amp;heightx=45.991561181435&amp;heightw=37.974683544304&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 fFAiTK title dynamic-sizing\">Cohen klar for</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">å avsløre Trump</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=\"Derfor forsvant han\" href=\"https://www.dagbladet.no/sport/derfor-forsvant-han/81394722\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Derfor forsvant han\" alt=\"Image: Derfor forsvant han\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81394748&amp;panoy=21.428571428571&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightx=20.361990950226&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 jdcGMN title dynamic-sizing\">Derfor forsvant han</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=\"Ekstremvarme: Minst ti døde\" href=\"https://www.dagbladet.no/nyheter/ekstremvarme-minst-ti-dode/81393367\"><figure class=\"x__sc-1an7vu1-0 cTplBD\"><picture><img data-defer=\"view\" title=\"Image: Ekstremvarme: Minst ti døde\" alt=\"Image: Ekstremvarme: Minst ti døde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81395093&amp;panoy=48.463357446809&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heighty=0&amp;heightx=36.77130044843&amp;width=402&amp;height=222&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 dyaAfc title dynamic-sizing\">Ekstremvarme:</span><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">Minst ti døde</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=\"Zelenskyjs to kriger\" href=\"https://www.dagbladet.no/nyheter/zelenskyjs-to-kriger/81345136\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Zelenskyjs to kriger\" alt=\"Image: Zelenskyjs to kriger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81031069&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=46.39175257732&amp;heighth=100&amp;heighty=0&amp;heightx=25.158969072165&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 iAWFly title dynamic-sizing\">Zelenskyjs</span><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">to kriger</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=\"Store NRK-endringer: Bekrefter\" href=\"https://www.dagbladet.no/nyheter/store-nrk-endringer-bekrefter/81394979\"><figure class=\"x__sc-1an7vu1-0 epIDcn\"><picture><img data-defer=\"view\" title=\"Image: Store NRK-endringer: Bekrefter\" alt=\"Image: Store NRK-endringer: Bekrefter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81395163&amp;panox=0&amp;panow=99.89939637827&amp;panoh=100&amp;panoy=0&amp;heightx=0&amp;heightw=99.89939637827&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=306&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 jdgMzU title dynamic-sizing\">Store NRK-endringer:</span><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">Bekrefter</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=\"Totalslakt: - Sjokkerende\" href=\"https://www.dagbladet.no/sport/totalslakt-sjokkerende/81393182\"><figure class=\"x__sc-1an7vu1-0 hRlocb\"><picture><img data-defer=\"view\" title=\"Image: Totalslakt: - Sjokkerende\" alt=\"Image: Totalslakt: - Sjokkerende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81395053&amp;panoy=38.888888888889&amp;panox=0&amp;panow=100&amp;panoh=32.87037037037&amp;heightx=25.874125874126&amp;heightw=62.937062937063&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=231&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\">Totalslakt:</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">- Sjokkerende</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=\"- Ansvarsløst\" href=\"https://www.dagbladet.no/kjendis/ansvarslost/81374616\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Ansvarsløst\" alt=\"Image: - Ansvarsløst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81394243&amp;panoy=26.5&amp;panox=0&amp;panow=100&amp;panoh=35.5&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 hQxAYP title dynamic-sizing\">- Ansvarsløst</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=\"Raser mot TV 2\" href=\"https://www.dagbladet.no/video/raser-mot-tv-2/2xzETyUN\"><figure class=\"x__sc-1an7vu1-0 FvIbz\"><picture><img data-defer=\"view\" title=\"Image: Raser mot TV 2\" alt=\"Image: Raser mot TV 2\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/2xzETyUN-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 jfvMWJ title dynamic-sizing\">Raser mot TV 2</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=\"La bort én ting - mistet magefettet \" href=\"https://www.dagbladet.no/tema/la-bort-n-ting-mistet-magefettet/81234538\"><figure class=\"x__sc-1an7vu1-0 iEicaO\"><picture><img data-defer=\"view\" title=\"Image: La bort én ting - mistet magefettet \" alt=\"Image: La bort én ting - mistet magefettet \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81235309&amp;panoy=37.891738461538&amp;panox=11.152416356877&amp;panow=78.686492936803&amp;panoh=62.108261538462&amp;heighty=0&amp;heightw=21.897810218978&amp;heighth=81.666666666667&amp;heightx=50.608272506083&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 gjHDge title dynamic-sizing\">La bort én ting -</span><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">mistet magefettet </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=\"Mannen bak fikk sjokk\" href=\"https://www.dagbladet.no/sport/trodde-aldri-han-skulle-gjore-det/81388764\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Mannen bak fikk sjokk\" alt=\"Image: Mannen bak fikk sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81389137&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=46.153846153846&amp;heightw=40.723981900452&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 dfgvpn title dynamic-sizing\">Mannen bak</span><span class=\"x__pt8tzk-0 jfcAvK title dynamic-sizing\">fikk sjokk</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=\"Brennhett: - Nesten for varmt for bunad\" href=\"https://www.dagbladet.no/nyheter/brennhett-nesten-for-varmt-for-bunad/81393415\"><figure class=\"x__sc-1an7vu1-0 clfoyJ\"><picture><img data-defer=\"view\" title=\"Image: Brennhett: - Nesten for varmt for bunad\" alt=\"Image: Brennhett: - Nesten for varmt for bunad\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81394940&amp;panoy=66.190476190476&amp;panox=0&amp;panow=100&amp;panoh=33.809523809524&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=330&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 lplqa-d title dynamic-sizing\">Brennhett: - Nesten</span><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">for varmt for bunad</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 offer for fake news\" href=\"https://www.dagbladet.no/kjendis/ble-offer-for-fake-news/81393249\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ble offer for fake news\" alt=\"Image: Ble offer for fake news\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81393261&amp;panoy=9.4594594594595&amp;panox=3.6036036036036&amp;panow=94.594594594595&amp;panoh=47.972972972973&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">Ble offer</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">for fake news</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=\"Nye millioner til rensing\" href=\"https://www.dagbladet.no/nyheter/nye-millioner-til-rensing/81393259\"><figure class=\"x__sc-1an7vu1-0 cQSpuk\"><picture><img data-defer=\"view\" title=\"Image: Nye millioner til rensing\" alt=\"Image: Nye millioner til rensing\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=77449705&amp;panox=0&amp;panow=100&amp;panoh=45.121951219512&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=254&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 emaxbb title dynamic-sizing\">Nye millioner</span><span class=\"x__pt8tzk-0 hIOHzH title dynamic-sizing\">til rensing</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\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Psoriasisleddgikt: Hyller nye anbefalinger\" href=\"https://www.dagbladet.no/tema/psoriasisleddgikthyller-nye-anbefalinger/81148997\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Psoriasisleddgikt: Hyller nye anbefalinger\" alt=\"Image: Psoriasisleddgikt: Hyller nye anbefalinger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81178850&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=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 iYgBvA title dynamic-sizing\">Psoriasisleddgikt:</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Hyller nye anbefalinger</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-black\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sjåførens reaksjon hylles\" href=\"https://www.dagbladet.no/video/-karrierens-verste-fall/LVbLrxqc\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Sjåførens reaksjon hylles\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81390531.jpg?imageId=81390531&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/05/12/cd6aaacc-44e4-4f64-9231-0aa72fc85de9/gif3.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/12/cd6aaacc-44e4-4f64-9231-0aa72fc85de9/gif3.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 bNRoJL title dynamic-sizing\">Sjåførens</span><span class=\"x__pt8tzk-0 kxzaKl title dynamic-sizing\">reaksjon hylles</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=\"Én uteblir\" href=\"https://www.dagbladet.no/kjendis/en-uteblir/81393761\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Én uteblir\" alt=\"Image: Én uteblir\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81393160&amp;panow=100&amp;panoh=47.333333333333&amp;panoy=13.333333333333&amp;panox=0&amp;heightx=21.844660194175&amp;heightw=43.68932038835&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 gyIQtO title dynamic-sizing\">Én uteblir</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=\"Rykter: Liste med ti navn\" href=\"https://www.dagbladet.no/kjendis/rykter-liste-med-ti-navn/81391564\"><figure class=\"x__sc-1an7vu1-0 dUaGqQ\"><picture><img data-defer=\"view\" title=\"Image: Rykter: Liste med ti navn\" alt=\"Image: Rykter: Liste med ti navn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81393100&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=402&amp;height=260&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 gVRWAB title dynamic-sizing\">Rykter: Liste</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">med ti navn</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=\"Våknet til hærverk: - Sjokkert\" href=\"https://www.dagbladet.no/nyheter/vaknet-til-haerverk-sjokkert/81392254\"><figure class=\"x__sc-1an7vu1-0 evezpr\"><picture><img data-defer=\"view\" title=\"Image: Våknet til hærverk: - Sjokkert\" alt=\"Image: Våknet til hærverk: - Sjokkert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81392431&amp;panow=100&amp;panoh=32.420091324201&amp;panoy=50.228310502283&amp;panox=0&amp;heightx=15.602836879433&amp;heightw=63.829787234043&amp;heighth=100&amp;heighty=0&amp;width=402&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 hQxAYP title dynamic-sizing\">Våknet til</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">hærverk: - Sjokkert</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=\"Røykteppe velter inn: - Svært helseskadelig\" href=\"https://www.dagbladet.no/nyheter/roykteppe-velter-inn-svaert-helseskadelig/81392994\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Røykteppe velter inn: - Svært helseskadelig\" alt=\"Image: Røykteppe velter inn: - Svært helseskadelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81393214&amp;panoy=30.496453900709&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;heightx=51.58371040724&amp;heightw=40.723981900452&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 inksEV title dynamic-sizing\">Røykteppe velter inn:</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">- Svært helseskadelig</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=\"Kåring: Norges største innebandytalenter\" href=\"https://www.dagbladet.no/sport/karing-norges-storste-innebandytalenter/81316799\"><figure class=\"x__sc-1an7vu1-0 iQmtHL\"><picture><img data-defer=\"view\" title=\"Image: Kåring: Norges største innebandytalenter\" alt=\"Image: Kåring: Norges største innebandytalenter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81316855&amp;panox=11.363636363636&amp;panoy=18.181818181818&amp;panow=79.082492424242&amp;panoh=40.214647727273&amp;heighty=0&amp;heightw=40.994420091324&amp;heighth=99.847794520548&amp;heightx=31.050228310502&amp;width=320&amp;height=181&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\">Kåring: Norges største</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">innebandytalenter</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=\"Snapchat-tabbe: - 73 ubesvarte anrop\" href=\"https://www.dagbladet.no/video/snapchat-tabbe-73-ubesvarte-anrop/ClH5cTT8\"><figure class=\"x__sc-1an7vu1-0 iRrFGC\"><picture><img data-defer=\"view\" title=\"Image: Snapchat-tabbe: - 73 ubesvarte anrop\" alt=\"Image: Snapchat-tabbe: - 73 ubesvarte anrop\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/ClH5cTT8-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 gjHDge title dynamic-sizing\">Snapchat-tabbe:</span><span class=\"x__pt8tzk-0 ggUSon title dynamic-sizing\">- 73 ubesvarte anrop</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=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gutt skadd i penge-regn\" href=\"https://www.dagbladet.no/nyheter/gutt-skadd-i-penge-regn/81392809\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Gutt skadd i penge-regn\" alt=\"Image: Gutt skadd i penge-regn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81393172&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=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 bXDgwp title dynamic-sizing\">Gutt skadd</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">i penge-regn</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=\"Morgentrafikken: - Mye trøbbel\" href=\"https://www.dagbladet.no/nyheter/morgentrafikken-mye-trobbel/81393207\"><figure class=\"x__sc-1an7vu1-0 jjcUMQ\"><picture><img data-defer=\"view\" title=\"Image: Morgentrafikken: - Mye trøbbel\" alt=\"Image: Morgentrafikken: - Mye trøbbel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81393209&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=485&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 kNhGgX title dynamic-sizing\">Morgentrafikken:</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">- Mye trøbbel</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=\"Oslofjorden sliter: Oppvåkningen\" href=\"https://www.dagbladet.no/nyheter/oppvakningen/81367563\"><figure class=\"x__sc-1an7vu1-0 dYPbEE\"><picture><img data-defer=\"view\" title=\"Image: Oslofjorden sliter: Oppvåkningen\" alt=\"Image: Oslofjorden sliter: Oppvåkningen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81367571&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=402&amp;height=323&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 jdgMzU title dynamic-sizing\">Oslofjorden sliter:</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Oppvåkningen</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=\"Om kjæresten: - Er ikke «skjuling»\" href=\"https://www.dagbladet.no/sport/om-kjaeresten-er-ikke-skjuling/81372449\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Om kjæresten: - Er ikke «skjuling»\" alt=\"Image: Om kjæresten: - Er ikke «skjuling»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81372690&amp;panow=86.41975308642&amp;panoy=26.543209876543&amp;panox=2.880658436214&amp;panoh=21.913580246914&amp;heightw=41.666666666667&amp;heighth=50.689655172414&amp;heighty=25.172413793103&amp;heightx=24.537037037037&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 hsPeia title dynamic-sizing\">Om kjæresten: - Er</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">ikke «skjuling»</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 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=\"Slettet video: - De stilnet deg\" href=\"https://www.dagbladet.no/video/irland-slettet-video-stilnet-deg/qo4k79IQ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Slettet video: - De stilnet deg\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81389165.jpg?imageId=81389165&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/11/6bc06264-545d-4896-b0d3-e2230a643e07/gifbambi1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/11/6bc06264-545d-4896-b0d3-e2230a643e07/gifbambi1.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 gLHLEv title dynamic-sizing\">Slettet video:</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">- De stilnet deg</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=\"Synsvansker røpet alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/synsvansker-ropet-alvorlig-sykdom/81279388\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Synsvansker røpet alvorlig sykdom\" alt=\"Image: Synsvansker røpet alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81288776&amp;panow=100&amp;panoh=100&amp;panox=0&amp;panoy=0&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 cyVXzf title dynamic-sizing\">Synsvansker røpet</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">alvorlig sykdom</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=\"- Blir party i hver by\" href=\"https://www.dagbladet.no/kjendis/blir-party-i-hver-by/81381074\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Blir party i hver by\" alt=\"Image: - Blir party i hver by\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81392551&amp;panoy=24.199288256228&amp;panox=0&amp;panow=100&amp;panoh=25.622775800712&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">- Blir party</span><span class=\"x__pt8tzk-0 gXQhrg title dynamic-sizing\">i hver by</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=\"Hamas-leder ikke i Rafah\" href=\"https://www.dagbladet.no/nyheter/hamas-leder-ikke-i-rafah/81392928\"><figure class=\"x__sc-1an7vu1-0 ioOUcG\"><picture><img data-defer=\"view\" title=\"Image: Hamas-leder ikke i Rafah\" alt=\"Image: Hamas-leder ikke i Rafah\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81392942&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=485&amp;height=294&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\">Hamas-leder</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">ikke i Rafah</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=\"Supermaten mot IBS: 76 prosent bedre!\" href=\"https://www.dagbladet.no/tema/ibs-grepet-76-prosent-bedre/81309320\"><figure class=\"x__sc-1an7vu1-0 dZwFXb\"><picture><img data-defer=\"view\" title=\"Image: Supermaten mot IBS: 76 prosent bedre!\" alt=\"Image: Supermaten mot IBS: 76 prosent bedre!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81309334&amp;panox=0&amp;panow=100&amp;panoh=47.333333333333&amp;panoy=23.333333333333&amp;heightx=30.733944954128&amp;heighty=0&amp;heightw=41.284403669725&amp;heighth=94.230769230769&amp;width=320&amp;height=182&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\">Supermaten mot IBS:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">76 prosent bedre!</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=\"Storfavoritten går på en smell\" href=\"https://www.dagbladet.no/video/storfavoritten-gar-pa-en-smell/eAk0CiL2\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Storfavoritten går på en smell\" alt=\"Image: Storfavoritten går på en smell\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/eAk0CiL2-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\">Storfavoritten</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">går på en smell</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=\"Kan bli smittehopp i sommer\" href=\"https://www.dagbladet.no/nyheter/kan-bli-smittehopp-i-sommer/81383051\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Kan bli smittehopp i sommer\" alt=\"Image: Kan bli smittehopp i sommer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81385073&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 bNRoJL title dynamic-sizing\">Kan bli smittehopp</span><span class=\"x__pt8tzk-0 eElPMU title dynamic-sizing\">i sommer</span></h3></header></a></article><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=\"- Katastrofale konsekvenser\" href=\"https://www.dagbladet.no/nyheter/katastrofale-konsekvenser/81377288\"><figure class=\"x__sc-1an7vu1-0 hPMFKU\"><picture><img data-defer=\"view\" title=\"Image: - Katastrofale konsekvenser\" alt=\"Image: - Katastrofale konsekvenser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81377350&amp;panoy=0&amp;panox=0&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heightx=47.085201793722&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heighty=0&amp;width=402&amp;height=349&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 bvXqXn title dynamic-sizing\">- Katastrofale</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">konsekvenser</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fanges på film\" href=\"https://www.dagbladet.no/video/fanges-pa-film/JHKLWAVS\"><figure class=\"x__sc-1an7vu1-0 kAAGbU\"><picture><img data-defer=\"view\" title=\"Image: Fanges på film\" alt=\"Image: Fanges på film\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/JHKLWAVS-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\">Fanges på film</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=\"Kari: - Ekstremt uattraktive menn\" href=\"https://www.dagbladet.no/tema/kari-ekstremt-uattraktive-menn/81319789\"><figure class=\"x__sc-1an7vu1-0 kAAGbU\"><picture><img data-defer=\"view\" title=\"Image: Kari: - Ekstremt uattraktive menn\" alt=\"Image: Kari: - Ekstremt uattraktive menn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81321453&amp;panow=100&amp;panoh=100&amp;panox=0&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=183&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\">Kari: - Ekstremt</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">uattraktive menn</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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Christina (25) viser kroppen: - Fornøyd\" href=\"https://www.dagbladet.no/tema/christina-25-viser-kroppen-fornoyd/81307753\"><figure class=\"x__sc-1an7vu1-0 hjJzLP\"><picture><img data-defer=\"view\" title=\"Image: Christina (25) viser kroppen: - Fornøyd\" alt=\"Image: Christina (25) viser kroppen: - Fornøyd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81308535&amp;panoy=23.970037453184&amp;panox=0&amp;panow=100&amp;panoh=27.715355805243&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=320&amp;height=216&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\">Christina (25) viser</span><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">kroppen: - Fornøyd</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=\"- Knuser russisk konvoi\" href=\"https://www.dagbladet.no/video/-knuser-russisk-konvoi/i9mMKmwg\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Knuser russisk konvoi\" alt=\"Image: - Knuser russisk konvoi\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/i9mMKmwg-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 iVreMl title dynamic-sizing\">- Knuser</span><span class=\"x__pt8tzk-0 eVBoHG title dynamic-sizing\">russisk konvoi</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\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Zelenskyj: Russland utvider fronten\" href=\"https://www.dagbladet.no/nyheter/zelenskyj-russland-utvider-fronten/81392738\"><figure class=\"x__sc-1an7vu1-0 kbQZSd\"><picture><img data-defer=\"view\" title=\"Image: Zelenskyj: Russland utvider fronten\" alt=\"Image: Zelenskyj: Russland utvider fronten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81031069&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=349&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 gPIxea title dynamic-sizing\">Zelenskyj: Russland</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">utvider fronten</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=\"Møtt av pipekonsert\" href=\"https://www.dagbladet.no/kjendis/mott-av-pipekonsert/81392716\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Møtt av pipekonsert\" alt=\"Image: Møtt av pipekonsert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81392724&amp;panoy=6&amp;panox=20.198675496689&amp;panow=69.867549668874&amp;panoh=36&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Møtt av</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">pipekonsert</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Amalie Iuel-klipp sett av sju millioner\" href=\"https://www.dagbladet.no/video/amalie-iuel-klipp-sett-av-sju-millioner/cntSR71y\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Amalie Iuel-klipp sett av sju millioner\" alt=\"Image: Amalie Iuel-klipp sett av sju millioner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/cntSR71y-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 kVJNPR title dynamic-sizing\">Amalie Iuel-klipp</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">sett av sju millioner</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=\"Venninnas uro: Den siste samtalen\" href=\"https://www.dagbladet.no/nyheter/venninnas-uro-den-siste-samtalen/81321361\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Venninnas uro: Den siste samtalen\" alt=\"Image: Venninnas uro: Den siste samtalen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76828491&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 iFlEmK title dynamic-sizing\">Venninnas uro:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Den siste samtalen</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\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sjokkfunn: Slik ble hun oppdaget\" href=\"https://www.dagbladet.no/nyheter/sjokkfunn-slik-ble-hun-oppdaget/81379765\"><figure class=\"x__sc-1an7vu1-0 imatiz\"><picture><img data-defer=\"view\" title=\"Image: Sjokkfunn: Slik ble hun oppdaget\" alt=\"Image: Sjokkfunn: Slik ble hun oppdaget\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81379990&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=402&amp;height=310&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 dyaAfc title dynamic-sizing\">Sjokkfunn: Slik</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">ble hun oppdaget</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=\"Krevde 40 000 fra «Spillet»-vinneren\" href=\"https://www.dagbladet.no/kjendis/krevde-40-000-fra-spillet-vinneren/81384101\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Krevde 40 000 fra «Spillet»-vinneren\" alt=\"Image: Krevde 40 000 fra «Spillet»-vinneren\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81384900&amp;panoy=17.362391304348&amp;panox=12.999675090253&amp;panow=74.187725631769&amp;panoh=37.771739130435&amp;heighty=16.212702702703&amp;heightw=22.551546391753&amp;heighth=55.405405405405&amp;heightx=39.518634020619&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 gVRWAB title dynamic-sizing\">Krevde 40 000 fra</span><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">«Spillet»-vinneren</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=\"Martins (71) demens-grep: Helt frisk\" href=\"https://www.dagbladet.no/tema/martins-71-demens-grep-helt-frisk/81274253\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Martins (71) demens-grep: Helt frisk\" alt=\"Image: Martins (71) demens-grep: Helt frisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81274882&amp;panoy=27.542372881356&amp;panox=0&amp;panow=100&amp;panoh=30.084745762712&amp;heightw=61.224489795918&amp;heighth=88.55421686747&amp;heighty=5.421686746988&amp;heightx=21.08843537415&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 jiGVVj title dynamic-sizing\">Martins (71)</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">demens-grep:</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">Helt frisk</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=\"Innrømmer «juks» i NRK-program\" href=\"https://www.dagbladet.no/video/innrommer-juks-i-nrk-program/lMkzrfpg\"><figure class=\"x__sc-1an7vu1-0 iGqPLB\"><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 cZmotM title dynamic-sizing\">i NRK-program</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=\"- Var smartere enn de andre\" href=\"https://www.dagbladet.no/kjendis/var-smartere-enn-de-andre/81386569\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Var smartere enn de andre\" alt=\"Image: - Var smartere enn de andre\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81386406&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=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 tqGkg title dynamic-sizing\">- Var smartere</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">enn de andre</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=\"Gigantisk kjøpesenter brant ned\" href=\"https://www.dagbladet.no/nyheter/gigantisk-kjopesenter-brant-ned/81392470\"><figure class=\"x__sc-1an7vu1-0 gUTrxt\"><picture><img data-defer=\"view\" title=\"Image: Gigantisk kjøpesenter brant ned\" alt=\"Image: Gigantisk kjøpesenter brant ned\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81392503&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=204&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\">Gigantisk</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">kjøpesenter</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">brant ned</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bildene fra USA sender sjokkbølger\" href=\"https://www.dagbladet.no/video/bildene-fra-usa-sender-sjokkbolger/vm6dZyHf\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Bildene fra USA sender sjokkbølger\" alt=\"Image: Bildene fra USA sender sjokkbølger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/vm6dZyHf-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 jIyTDK title dynamic-sizing\">Bildene fra</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">USA sender</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">sjokkbølger</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=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Quiz uke 16: Simens ti kjappe!\" href=\"https://www.dagbladet.no/nyheter/quiz-uke-16-simens-ti-kjappe/81286213\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Quiz uke 16: Simens ti kjappe!\" alt=\"Image: Quiz uke 16: Simens ti kjappe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81056783&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Quiz uke 16:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Simens ti kjappe!</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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avliver kjente narsissist-myter\" href=\"https://www.dagbladet.no/tema/avliver-kjente-narsissist-myter/81263299\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Avliver kjente narsissist-myter\" alt=\"Image: Avliver kjente narsissist-myter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81263965&amp;panoy=26.262626262626&amp;panow=76.413958844765&amp;panoh=36.700336363636&amp;panox=0&amp;heighty=0.22371409395974&amp;heightx=4.8076923076923&amp;heightw=44.0705125&amp;heighth=99.77628590604&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\">Avliver kjente</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">narsissist-myter</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=\"Klarer ikke stoppe: - Fader, altså!\" href=\"https://www.dagbladet.no/video/klarer-ikke-stoppe-fader-altsa/kLhO0qI7\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Klarer ikke stoppe: - Fader, altså!\" alt=\"Image: Klarer ikke stoppe: - Fader, altså!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kLhO0qI7-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 zWscE title dynamic-sizing\">Klarer ikke stoppe:</span><span class=\"x__pt8tzk-0 iITVJY title dynamic-sizing\">- Fader, altså!</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 bg-black\" 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 lynkjapt\" href=\"https://www.dagbladet.no/video/mister-balansen/rnZQXRE2\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Reagerer lynkjapt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81390566.jpg?imageId=81390566&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/05/10/09c4062e-33f4-4b2a-a7d5-109fa8c9d108/gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/10/09c4062e-33f4-4b2a-a7d5-109fa8c9d108/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 cGLrSG title dynamic-sizing\">Reagerer</span><span class=\"x__pt8tzk-0 jwrbOd title dynamic-sizing\">lynkjapt</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=\"Den farligste - og minst farlige snusen\" href=\"https://www.dagbladet.no/tema/den-farligste-og-minst-farlige-snusen/81206403\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Den farligste - og minst farlige snusen\" alt=\"Image: Den farligste - og minst farlige snusen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81212270&amp;panox=0&amp;panow=99.759615384615&amp;panoh=59.745762711864&amp;panoy=11.864406779661&amp;heightx=31.764705882353&amp;heighty=0.3448275862069&amp;heightw=34.705882352941&amp;heighth=100.34482758621&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 kVJNPR title dynamic-sizing\">Den farligste - og</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">minst farlige snusen</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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Magefett-studie: Ingrediensen som fjerner\" href=\"https://www.dagbladet.no/tema/magefett-studie-ingrediensen-som-fjerner/81173515\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Magefett-studie: Ingrediensen som fjerner\" alt=\"Image: Magefett-studie: Ingrediensen som fjerner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81179043&amp;panoy=2.1739130434783&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=51.288246376812&amp;heightw=40.808081818182&amp;heighth=99.847794520548&amp;heighty=0&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 gjHDge title dynamic-sizing\">Magefett-studie:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Ingrediensen</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">som fjerner</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=\"Utestengt på livstid etter dette\" href=\"https://www.dagbladet.no/video/utestengt-pa-livstid-etter-dette/JjRyUcQh\"><figure class=\"x__sc-1an7vu1-0 iPjCRj\"><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><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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ufrivillig singel: De vanligste tabbene\" href=\"https://www.dagbladet.no/tema/ufrivillig-singelde-vanligste-tabbene/81395739\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ufrivillig singel: De vanligste tabbene\" alt=\"Image: Ufrivillig singel: De vanligste tabbene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81395820&amp;panow=100.16260487805&amp;panoy=13.793103448276&amp;panox=0.16260487804878&amp;panoh=47.816096551724&amp;heightx=12.227074235808&amp;heightw=38.136829694323&amp;heighth=89.026919254658&amp;heighty=3.7267080745342&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\">Ufrivillig singel:</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">De vanligste tabbene</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=\"Angrep dypt inne i Russland\" href=\"https://www.dagbladet.no/video/angrep-dypt-inne-i-russland/QQaMwbw0\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><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></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\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tursko: - Vinneren er fantastisk\" href=\"https://www.dagbladet.no/tema/tursko-vinneren-er-fantastisk/81102936\"><figure class=\"x__sc-1an7vu1-0 eAYXY\"><picture><img data-defer=\"view\" title=\"Image: Tursko: - Vinneren er fantastisk\" alt=\"Image: Tursko: - Vinneren er fantastisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81368312&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&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 cyVXzf title dynamic-sizing\">Tursko: - Vinneren</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">er fantastisk</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=\"– Det er så respektløst!\" href=\"https://www.dagbladet.no/video/-det-er-sa-respektlost/61vlOQno\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: – Det er så respektløst!\" alt=\"Image: – Det er så respektløst!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/61vlOQno-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 ivnriz title dynamic-sizing\">– Det er så</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">respektløst!</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>"]