FRANK LØKE-STIKK?
Nettet koker:- Helt ellevilt
Magefett-formelen:Borte på 10 uker
Annonsørinnhold
Meskerkokken har énviktig grill-regel
i samarbeid medStoltenberg raser:- Alvorlige konsekvenser
Fikk ALS -skal dø snart
Annonsørinnhold
Vanvittig salgpå merkeklær
i samarbeid med
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
AKKURAT NÅ:
FREDRIKSTAD:
- Lukk vinduene
Bekrefter: Må få lov
["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .QgvhR.QgvhR.QgvhR.QgvhR{height:0;padding-bottom:53.19%;}/*!sc*/ .hTZISu.hTZISu.hTZISu.hTZISu{height:0;padding-bottom:63.91%;}/*!sc*/ .jqAWdU.jqAWdU.jqAWdU.jqAWdU{height:0;padding-bottom:73.43%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .eekAZq.eekAZq.eekAZq.eekAZq{height:0;padding-bottom:56.71%;}/*!sc*/ .fVUhDR.fVUhDR.fVUhDR.fVUhDR{height:0;padding-bottom:101.24%;}/*!sc*/ .aqCCR.aqCCR.aqCCR.aqCCR{height:0;padding-bottom:52.5%;}/*!sc*/ .enkXHZ.enkXHZ.enkXHZ.enkXHZ{height:0;padding-bottom:83.5%;}/*!sc*/ .egkHoC.egkHoC.egkHoC.egkHoC{height:0;padding-bottom:59.45%;}/*!sc*/ .kAAGbU.kAAGbU.kAAGbU.kAAGbU{height:0;padding-bottom:57.18%;}/*!sc*/ .ibyVuT.ibyVuT.ibyVuT.ibyVuT{height:0;padding-bottom:56.25%;}/*!sc*/ .jfpqYD.jfpqYD.jfpqYD.jfpqYD{height:0;padding-bottom:58.76%;}/*!sc*/ .ixhAMx.ixhAMx.ixhAMx.ixhAMx{height:0;padding-bottom:54.43%;}/*!sc*/ .boyxgd.boyxgd.boyxgd.boyxgd{height:0;padding-bottom:54.47%;}/*!sc*/ .evezpr.evezpr.evezpr.evezpr{height:0;padding-bottom:64.42%;}/*!sc*/ .bAQDZy.bAQDZy.bAQDZy.bAQDZy{height:0;padding-bottom:93.43%;}/*!sc*/ .bMwBVW.bMwBVW.bMwBVW.bMwBVW{height:0;padding-bottom:89.37%;}/*!sc*/ .YTIkI.YTIkI.YTIkI.YTIkI{height:0;padding-bottom:55.47%;}/*!sc*/ .jbNkVD.jbNkVD.jbNkVD.jbNkVD{height:0;padding-bottom:119.9%;}/*!sc*/ .gOIzNO.gOIzNO.gOIzNO.gOIzNO{height:0;padding-bottom:54.84%;}/*!sc*/ .lbczJt.lbczJt.lbczJt.lbczJt{height:0;padding-bottom:69.9%;}/*!sc*/ .cQSpuk.cQSpuk.cQSpuk.cQSpuk{height:0;padding-bottom:52.37%;}/*!sc*/ .cIfcrt.cIfcrt.cIfcrt.cIfcrt{height:0;padding-bottom:56.49%;}/*!sc*/ .iRrFGC.iRrFGC.iRrFGC.iRrFGC{height:0;padding-bottom:54.37%;}/*!sc*/ .ilNZJn.ilNZJn.ilNZJn.ilNZJn{height:0;padding-bottom:101.99%;}/*!sc*/ .fwaYEb.fwaYEb.fwaYEb.fwaYEb{height:0;padding-bottom:123.88%;}/*!sc*/ .ejHyWU.ejHyWU.ejHyWU.ejHyWU{height:0;padding-bottom:63.75%;}/*!sc*/ .dFQuBj.dFQuBj.dFQuBj.dFQuBj{height:0;padding-bottom:66.59%;}/*!sc*/ .isdgsy.isdgsy.isdgsy.isdgsy{height:0;padding-bottom:82.47%;}/*!sc*/ .ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .cCuzIK.cCuzIK.cCuzIK.cCuzIK{height:0;padding-bottom:108.95%;}/*!sc*/ .kLZUyf.kLZUyf.kLZUyf.kLZUyf{height:0;padding-bottom:60.93%;}/*!sc*/ .bcRKOI.bcRKOI.bcRKOI.bcRKOI{height:0;padding-bottom:96.51%;}/*!sc*/ .gkSegO.gkSegO.gkSegO.gkSegO{height:0;padding-bottom:65.93%;}/*!sc*/ .cjSQRT.cjSQRT.cjSQRT.cjSQRT{height:0;padding-bottom:81.09%;}/*!sc*/ .fgisev.fgisev.fgisev.fgisev{height:0;padding-bottom:72.18%;}/*!sc*/ .ebIGPt.ebIGPt.ebIGPt.ebIGPt{height:0;padding-bottom:52.81%;}/*!sc*/ .kuSVct.kuSVct.kuSVct.kuSVct{height:0;padding-bottom:60.62%;}/*!sc*/ data-styled.g371[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,fnQDHb,QgvhR,hTZISu,jqAWdU,kviAry,eekAZq,fVUhDR,aqCCR,enkXHZ,egkHoC,kAAGbU,ibyVuT,jfpqYD,ixhAMx,boyxgd,evezpr,bAQDZy,bMwBVW,YTIkI,jbNkVD,gOIzNO,lbczJt,cQSpuk,cIfcrt,iRrFGC,ilNZJn,fwaYEb,ejHyWU,dFQuBj,isdgsy,ejnyBo,cCuzIK,kLZUyf,bcRKOI,gkSegO,cjSQRT,fgisev,ebIGPt,kuSVct,\"}/*!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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .bHxiDg.bHxiDg.bHxiDg.bHxiDg{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bHxiDg.bHxiDg.bHxiDg.bHxiDg{font-size:1.6em!important;}}/*!sc*/ .fWAkyl.fWAkyl.fWAkyl.fWAkyl{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fWAkyl.fWAkyl.fWAkyl.fWAkyl{font-size:1.8em!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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .kLBvft.kLBvft.kLBvft.kLBvft{font-size:7.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kLBvft.kLBvft.kLBvft.kLBvft{font-size:2.6em!important;}}/*!sc*/ .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*/ .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*/ .zWscE.zWscE.zWscE.zWscE{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.zWscE.zWscE.zWscE.zWscE{font-size:0.7em!important;}}/*!sc*/ .dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:0.6em!important;}}/*!sc*/ .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*/ .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*/ .emKkIi.emKkIi.emKkIi.emKkIi{font-size:10.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.emKkIi.emKkIi.emKkIi.emKkIi{font-size:3.7em!important;}}/*!sc*/ .jijxuQ.jijxuQ.jijxuQ.jijxuQ{font-size:9.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jijxuQ.jijxuQ.jijxuQ.jijxuQ{font-size:3.2em!important;}}/*!sc*/ .dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:1.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .hRXaXr.hRXaXr.hRXaXr.hRXaXr{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.hRXaXr.hRXaXr.hRXaXr.hRXaXr{font-size:1.4em!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*/ .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*/ .iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .izSfmh.izSfmh.izSfmh.izSfmh{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.izSfmh.izSfmh.izSfmh.izSfmh{font-size:1.6em!important;}}/*!sc*/ .gpXVuT.gpXVuT.gpXVuT.gpXVuT{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gpXVuT.gpXVuT.gpXVuT.gpXVuT{font-size:2.2em!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*/ .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*/ .jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:1.1em!important;}}/*!sc*/ .lfBuL.lfBuL.lfBuL.lfBuL{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.lfBuL.lfBuL.lfBuL.lfBuL{font-size:1.3em!important;}}/*!sc*/ .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*/ .glOqqI.glOqqI.glOqqI.glOqqI{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.glOqqI.glOqqI.glOqqI.glOqqI{font-size:1.4em!important;}}/*!sc*/ .jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:1.8em!important;}}/*!sc*/ .egjpuh.egjpuh.egjpuh.egjpuh{font-size:8.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.egjpuh.egjpuh.egjpuh.egjpuh{font-size:2.9em!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*/ .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*/ .hbQXRv.hbQXRv.hbQXRv.hbQXRv{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.hbQXRv.hbQXRv.hbQXRv.hbQXRv{font-size:2.6em!important;}}/*!sc*/ .iWZcdV.iWZcdV.iWZcdV.iWZcdV{font-size:9.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iWZcdV.iWZcdV.iWZcdV.iWZcdV{font-size:3.3em!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*/ .kauVAS.kauVAS.kauVAS.kauVAS{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kauVAS.kauVAS.kauVAS.kauVAS{font-size:2.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .dUqYKO.dUqYKO.dUqYKO.dUqYKO{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dUqYKO.dUqYKO.dUqYKO.dUqYKO{font-size:2.2em!important;}}/*!sc*/ .fYNSni.fYNSni.fYNSni.fYNSni{font-size:8.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.fYNSni.fYNSni.fYNSni.fYNSni{font-size:3.2em!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*/ .kkHfrE.kkHfrE.kkHfrE.kkHfrE{font-size:8.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kkHfrE.kkHfrE.kkHfrE.kkHfrE{font-size:2.9em!important;}}/*!sc*/ .iEukpb.iEukpb.iEukpb.iEukpb{font-size:8.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iEukpb.iEukpb.iEukpb.iEukpb{font-size:3.1em!important;}}/*!sc*/ .BsLeO.BsLeO.BsLeO.BsLeO{font-size:2.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.BsLeO.BsLeO.BsLeO.BsLeO{font-size:0.8em!important;}}/*!sc*/ .jXDBAT.jXDBAT.jXDBAT.jXDBAT{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jXDBAT.jXDBAT.jXDBAT.jXDBAT{font-size:1.1em!important;}}/*!sc*/ .kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:8.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:2.9em!important;}}/*!sc*/ .criDNb.criDNb.criDNb.criDNb{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.criDNb.criDNb.criDNb.criDNb{font-size:2em!important;}}/*!sc*/ .cVlLEd.cVlLEd.cVlLEd.cVlLEd{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cVlLEd.cVlLEd.cVlLEd.cVlLEd{font-size:1.1em!important;}}/*!sc*/ .eVVsXT.eVVsXT.eVVsXT.eVVsXT{font-size:7.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.eVVsXT.eVVsXT.eVVsXT.eVVsXT{font-size:2.5em!important;}}/*!sc*/ .bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:1.6em!important;}}/*!sc*/ .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*/ .ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:6.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:2.4em!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*/ .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*/ .iLHueX.iLHueX.iLHueX.iLHueX{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iLHueX.iLHueX.iLHueX.iLHueX{font-size:1.6em!important;}}/*!sc*/ .cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:1.7em!important;}}/*!sc*/ .gNDiBf.gNDiBf.gNDiBf.gNDiBf{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gNDiBf.gNDiBf.gNDiBf.gNDiBf{font-size:2.3em!important;}}/*!sc*/ .dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:0.6em!important;}}/*!sc*/ .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*/ .fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:1.5em!important;}}/*!sc*/ .jkoItf.jkoItf.jkoItf.jkoItf{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jkoItf.jkoItf.jkoItf.jkoItf{font-size:0.7em!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*/ .kYsbxS.kYsbxS.kYsbxS.kYsbxS{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kYsbxS.kYsbxS.kYsbxS.kYsbxS{font-size:1.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*/ .dAsdTT.dAsdTT.dAsdTT.dAsdTT{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dAsdTT.dAsdTT.dAsdTT.dAsdTT{font-size:1.2em!important;}}/*!sc*/ data-styled.g372[id=\"x__pt8tzk-0\"]{content:\"jiGVVj,cyVXzf,fIeyCx,dyaAfc,jGSTdz,jdcGMN,wpWLG,eYoKgk,frzFun,iYgBvA,bHxiDg,fWAkyl,hrVcDN,bwzwBX,epoJzD,jfvMWJ,LzBnW,gyIQtO,kLBvft,dfserP,iFlEmK,zWscE,dDKeDQ,ftetSQ,emaxbb,emKkIi,jijxuQ,dfgvpn,hsPeia,gVRWAB,kVJNPR,hRXaXr,gjHDge,gPIxea,iXjdLY,fFAiTK,kNhGgX,izSfmh,gpXVuT,hQxAYP,dBWQRi,inksEV,jEhvtw,lfBuL,iNHyie,glOqqI,jFsmoq,egjpuh,dJenrE,bxtuZJ,hbQXRv,iWZcdV,gLHLEv,kauVAS,ddbCJZ,iAWFly,gXQhrg,dWzMnA,tqGkg,kMqJSM,jdgMzU,fNDhDy,dUqYKO,fYNSni,bWSnVS,kkHfrE,iEukpb,BsLeO,jXDBAT,kUqUJf,criDNb,cVlLEd,eVVsXT,bkgkdp,ivnriz,ldTjgH,bwGQrt,ijicdz,iLHueX,cnjOqe,gNDiBf,dPoeFo,cFtCN,jRIgeY,fTAjeM,jkoItf,cZmotM,kYsbxS,itkiNJ,dAsdTT,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div id=\"apos-netboard3\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"På innsiden: Tabu-fest i Bergen\" href=\"https://www.dagbladet.no/tema/tabu-fest-i-bergen-hun-hyler/81348069\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: På innsiden: Tabu-fest i Bergen\" alt=\"Image: På innsiden: Tabu-fest i Bergen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81385549&amp;panoy=26.950354609929&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=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 jiGVVj title dynamic-sizing\">På innsiden:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Tabu-fest i Bergen</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=\"Kastet ut av NRK-debatt: - Ødela mye\" href=\"https://www.dagbladet.no/video/kastet-ut-av-nrk-debatt-odela-mye/kYqjsS6r\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Kastet ut av NRK-debatt: - Ødela mye\" alt=\"Image: Kastet ut av NRK-debatt: - Ødela mye\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kYqjsS6r-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 fIeyCx title dynamic-sizing\">Kastet ut av</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">NRK-debatt:</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">- Ødela mye</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=\"Mann i sjøen - person pågrepet\" href=\"https://www.dagbladet.no/nyheter/mann-i-sjoen-person-pagrepet/81403949\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Mann i sjøen - person pågrepet\" alt=\"Image: Mann i sjøen - person pågrepet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81403968&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=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 jGSTdz title dynamic-sizing\">Mann i sjøen -</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">person pågrepet</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=\"Politiet: - Utelukker ikke kidnapping\" href=\"https://www.dagbladet.no/nyheter/politiet-utelukker-ikke-kidnapping/81396649\"><figure class=\"x__sc-1an7vu1-0 QgvhR\"><picture><img data-defer=\"view\" title=\"Image: Politiet: - Utelukker ikke kidnapping\" alt=\"Image: Politiet: - Utelukker ikke kidnapping\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396776&amp;panoy=12.260536398467&amp;panox=0&amp;panow=99.842766981132&amp;panoh=27.841634482759&amp;heightw=42.242703225806&amp;heightx=25.806451612903&amp;heighth=55.266418587361&amp;heighty=4.8327137546468&amp;width=485&amp;height=258&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 wpWLG title dynamic-sizing\">Politiet: - Utelukker</span><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">ikke kidnapping</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=\"Skapte overskrifter i natt\" href=\"https://www.dagbladet.no/sport/skapte-overskrifter-i-natt/81398767\"><figure class=\"x__sc-1an7vu1-0 hTZISu\"><picture><img data-defer=\"view\" title=\"Image: Skapte overskrifter i natt\" alt=\"Image: Skapte overskrifter i natt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398775&amp;panoy=6.5693430656934&amp;panox=0.16025673076923&amp;panow=100.16025673077&amp;panoh=52.068127007299&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=485&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 frzFun title dynamic-sizing\">Skapte overskrifter i natt</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=\"600 menn på ett år: Avslører sjokklønn\" href=\"https://www.dagbladet.no/nyheter/600-menn-pa-ett-ar-avslorer-sjokklonn/81395466\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: 600 menn på ett år: Avslører sjokklønn\" alt=\"Image: 600 menn på ett år: Avslører sjokklønn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396316&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">600 menn på ett år:</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Avslører sjokklønn</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=\"Russland: Advarer innbyggerne\" href=\"https://www.dagbladet.no/video/russland-advarer-innbyggerne/ofOiqfev\"><figure class=\"x__sc-1an7vu1-0 jqAWdU\"><picture><img data-defer=\"view\" title=\"Image: Russland: Advarer innbyggerne\" alt=\"Image: Russland: Advarer innbyggerne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/ofOiqfev-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\">Russland: Advarer</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">innbyggerne</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=\"- Jeg ble voldtatt\" href=\"https://www.dagbladet.no/kjendis/jeg-ble-voldtatt/81035724\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Jeg ble voldtatt\" alt=\"Image: - Jeg ble voldtatt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81209010&amp;panox=0.086579999999997&amp;panow=100.08658&amp;panoh=51.558441428571&amp;panoy=14.285714285714&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 bHxiDg title dynamic-sizing\">- Jeg ble</span><span class=\"x__pt8tzk-0 fWAkyl title dynamic-sizing\">voldtatt</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=\"Ekspert: Vrakes\" href=\"https://www.dagbladet.no/sport/ekspert-vrakes/81400454\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Ekspert: Vrakes\" alt=\"Image: Ekspert: Vrakes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81356069&amp;panox=0&amp;panow=100&amp;panoh=51.824817518248&amp;panoy=19.70802919708&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 hrVcDN title dynamic-sizing\">Ekspert: Vrakes</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=\"AUF-slakt: - Reagerer veldig\" href=\"https://www.dagbladet.no/nyheter/auf-slakt-reagerer-veldig/81384094\"><figure class=\"x__sc-1an7vu1-0 eekAZq\"><picture><img data-defer=\"view\" title=\"Image: AUF-slakt: - Reagerer veldig\" alt=\"Image: AUF-slakt: - Reagerer veldig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81384915&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=402&amp;height=228&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\">AUF-slakt:</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">- Reagerer veldig</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=\"Omkom etter biljakt - identifisert\" href=\"https://www.dagbladet.no/nyheter/omkom-etter-biljakt-identifisert/81403377\"><figure class=\"x__sc-1an7vu1-0 fVUhDR\"><picture><img data-defer=\"view\" title=\"Image: Omkom etter biljakt - identifisert\" alt=\"Image: Omkom etter biljakt - identifisert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81403393&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=33.031674208145&amp;heightw=40.723981900452&amp;heighth=100&amp;width=402&amp;height=407&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 jfvMWJ title dynamic-sizing\">Omkom etter biljakt</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">- identifisert</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=\"Hudfletter Eurovision\" href=\"https://www.dagbladet.no/kjendis/hudfletter-eurovision/81393157\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><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=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\">Hudfletter</span><span class=\"x__pt8tzk-0 kLBvft title dynamic-sizing\">Eurovision</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Lover Ukraina 50 hver måned\" href=\"https://www.dagbladet.no/video/lover-ukraina-50-hver-maned/ggYF0q3p\"><figure class=\"x__sc-1an7vu1-0 aqCCR\"><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><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=\"Advokat: Styr unna framtidsfullmakt-fella \" href=\"https://www.dagbladet.no/tema/advokat-styr-unna-framtidsfullmakt-fella/81077382\"><figure class=\"x__sc-1an7vu1-0 aqCCR\"><picture><img data-defer=\"view\" title=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" alt=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81242728&amp;panoy=16.551724137931&amp;panox=0.083402752293575&amp;panow=100.08340275229&amp;panoh=51.159874482759&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=320&amp;height=168&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Advokat: Styr unna</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">framtidsfullmakt-fella </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=\"Deler sjeldent bilde av barna\" href=\"https://www.dagbladet.no/kjendis/deler-sjeldent-bilde-av-barna/81395007\"><figure class=\"x__sc-1an7vu1-0 enkXHZ\"><picture><img data-defer=\"view\" title=\"Image: Deler sjeldent bilde av barna\" alt=\"Image: Deler sjeldent bilde av barna\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81395293&amp;panoy=13.207547169811&amp;panox=0&amp;panow=99.842766981132&amp;panoh=45.702305660377&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=405&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">Deler sjeldent</span><span class=\"x__pt8tzk-0 emaxbb title dynamic-sizing\">bilde av barna</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=\"- Aldri sett før\" href=\"https://www.dagbladet.no/kjendis/aldri-sett-for/81397975\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Aldri sett før\" alt=\"Image: - Aldri sett før\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398083&amp;panoy=8.9005235602094&amp;panow=99.932614150943&amp;panoh=38.14510052356&amp;panox=0&amp;heighty=0&amp;heightx=17.801047120419&amp;heightw=48.092744502618&amp;heighth=86.044590751445&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 emKkIi title dynamic-sizing\">- Aldri</span><span class=\"x__pt8tzk-0 jijxuQ title dynamic-sizing\">sett før</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=\"Kan være over\" href=\"https://www.dagbladet.no/sport/kan-vaere-over/81399028\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Kan være over\" alt=\"Image: Kan være over\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81399043&amp;panoy=8.1081081081081&amp;panox=0&amp;panow=100&amp;panoh=47.972972972973&amp;heightw=100&amp;heighth=100&amp;heighty=0&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 dfgvpn title dynamic-sizing\">Kan være over</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=\"Døde: - Holdt hånda hennes\" href=\"https://www.dagbladet.no/kjendis/dode-holdt-handa-hennes/81395456\"><figure class=\"x__sc-1an7vu1-0 egkHoC\"><picture><img data-defer=\"view\" title=\"Image: Døde: - Holdt hånda hennes\" alt=\"Image: Døde: - Holdt hånda hennes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396036&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=239&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\">Døde: - Holdt</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">hånda hennes</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=\"Kan endre kampene i krigen\" href=\"https://www.dagbladet.no/video/kan-endre-kampene-i-krigen/CHxHBCyx\"><figure class=\"x__sc-1an7vu1-0 kAAGbU\"><picture><img data-defer=\"view\" title=\"Image: Kan endre kampene i krigen\" alt=\"Image: Kan endre kampene i krigen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/CHxHBCyx-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 gVRWAB title dynamic-sizing\">Kan endre</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">kampene i krigen</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=\"Torill (41) raste ned 20 kilo\" href=\"https://www.dagbladet.no/tema/torill-41-raste-ned-20-kilo/81362472\"><figure class=\"x__sc-1an7vu1-0 ibyVuT\"><picture><img data-defer=\"view\" title=\"Image: Torill (41) raste ned 20 kilo\" alt=\"Image: Torill (41) raste ned 20 kilo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81387945&amp;panoy=13.04347826087&amp;panox=0&amp;panow=100&amp;panoh=50.724637681159&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=320&amp;height=180&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 hRXaXr title dynamic-sizing\">Torill (41)</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">raste ned 20 kilo</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gladnyhet til deg som er glad i disse\" href=\"https://tinyurl.com/energidrikke2?allerID=1202405071\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Gladnyhet til deg som er glad i disse\" alt=\"Image: Gladnyhet til deg som er glad i disse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81366836.jpg?imageId=81366836&amp;x=0.000000&amp;y=8.166969&amp;cropw=100.000000&amp;croph=80.036298&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 gjHDge title dynamic-sizing\">Gladnyhet til deg</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">som er glad i disse</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></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=\"Beordrer politiet etter brutalt overfall\" href=\"https://www.dagbladet.no/nyheter/beordrer-politiet-etter-brutalt-overfall/81402291\"><figure class=\"x__sc-1an7vu1-0 jfpqYD\"><picture><img data-defer=\"view\" title=\"Image: Beordrer politiet etter brutalt overfall\" alt=\"Image: Beordrer politiet etter brutalt overfall\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81403059&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=485&amp;height=285&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\">Beordrer politiet</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">etter brutalt overfall</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=\"Vekker harme: - Aldri trygg\" href=\"https://www.dagbladet.no/nyheter/vekker-harme-aldri-trygg/81399305\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Vekker harme: - Aldri trygg\" alt=\"Image: Vekker harme: - Aldri trygg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81399339&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=34.375&amp;heightw=40.85648125&amp;heighth=99.676857718121&amp;heighty=0.32314228187919&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 iXjdLY title dynamic-sizing\">Vekker harme:</span><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">- Aldri trygg</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=\"Kommer med DiCaprio-stikk\" href=\"https://www.dagbladet.no/kjendis/kommer-med-dicaprio-stikk/81399460\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Kommer med DiCaprio-stikk\" alt=\"Image: Kommer med DiCaprio-stikk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81399895&amp;panow=99.842766981132&amp;panoh=25.144175086505&amp;panoy=17.993079584775&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 hrVcDN title dynamic-sizing\">Kommer med</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">DiCaprio-stikk</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=\"- Vil ikke knuse for mange hjerter\" href=\"https://www.dagbladet.no/kjendis/vil-ikke-knuse-for-mange-hjerter/81386468\"><figure class=\"x__sc-1an7vu1-0 ixhAMx\"><picture><img data-defer=\"view\" title=\"Image: - Vil ikke knuse for mange hjerter\" alt=\"Image: - Vil ikke knuse for mange hjerter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81386959&amp;panoy=11.326860841424&amp;panox=0&amp;panow=100&amp;panoh=22.977346278317&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=264&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\">- Vil ikke knuse</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">for mange hjerter</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard5\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"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 fjJyvE\"><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=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\">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-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=\"Her viser hun alt\" href=\"https://www.dagbladet.no/video/vekker-oppsikt/gWAcRJtC\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Her viser hun alt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81389628.jpg?imageId=81389628&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=100.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/11/c283cf2c-1d00-4e1e-bd9d-95e7650dc5f1/portugalgif2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/11/c283cf2c-1d00-4e1e-bd9d-95e7650dc5f1/portugalgif2.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 izSfmh title dynamic-sizing\">Her viser</span><span class=\"x__pt8tzk-0 gpXVuT title dynamic-sizing\">hun alt</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=\"Døde seks ganger\" href=\"https://www.dagbladet.no/sport/dode-seks-ganger/81400382\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Døde seks ganger\" alt=\"Image: Døde seks ganger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81400713&amp;panoy=36.708860759494&amp;panox=0&amp;panow=100&amp;panoh=44.936708860759&amp;heighth=100&amp;heighty=0&amp;heightx=22.448979591837&amp;heightw=45.918367346939&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\">Døde seks ganger</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=\"Store NRK-endringer: Bekrefter\" href=\"https://www.dagbladet.no/nyheter/store-nrk-endringer-bekrefter/81394979\"><figure class=\"x__sc-1an7vu1-0 boyxgd\"><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=402&amp;height=219&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 kVJNPR title dynamic-sizing\">Store NRK-endringer:</span><span class=\"x__pt8tzk-0 hQxAYP 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=\"Ny beskjed: Har mistet evne\" href=\"https://www.dagbladet.no/kjendis/ny-beskjed-har-mistet-evne/81396782\"><figure class=\"x__sc-1an7vu1-0 evezpr\"><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=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 dBWQRi title dynamic-sizing\">Ny beskjed:</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Har mistet evne</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=\"Trumps eks-advokat: - Tenkte ikke på Melania\" href=\"https://www.dagbladet.no/nyheter/trumps-eks-advokat-tenkte-ikke-pa-melania/81398919\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Trumps eks-advokat: - Tenkte ikke på Melania\" alt=\"Image: Trumps eks-advokat: - Tenkte ikke på Melania\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398985&amp;panoy=8.6330935251799&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=50.91926618705&amp;heighty=0&amp;heightx=26.48401826484&amp;heightw=40.994420091324&amp;heighth=99.847794520548&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\">Trumps eks-advokat:</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">- Tenkte ikke på Melania</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 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=\"Ender fatalt\" href=\"https://www.dagbladet.no/video/krasjer-under-jagerfly-stunt-/qUQV0hUR\"><figure class=\"x__sc-1an7vu1-0 bAQDZy moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Ender fatalt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81397839.jpg?imageId=81397839&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=299\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/13/c06f9a6f-8d45-45bc-a323-bdc0263422fe/jagerfly_gif_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/13/c06f9a6f-8d45-45bc-a323-bdc0263422fe/jagerfly_gif_2.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 lfBuL title dynamic-sizing\">Ender fatalt</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=\"Åpner opp om sykdommen: - Redd\" href=\"https://www.dagbladet.no/kjendis/apner-opp-om-sykdommen-redd/81269893\"><figure class=\"x__sc-1an7vu1-0 bMwBVW\"><picture><img data-defer=\"view\" title=\"Image: Åpner opp om sykdommen: - Redd\" alt=\"Image: Åpner opp om sykdommen: - Redd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81271174&amp;panox=0&amp;panow=99.893674641148&amp;panoh=50.91926618705&amp;panoy=13.669064748201&amp;heightx=23.744292237443&amp;heightw=40.994420091324&amp;heighth=99.847794520548&amp;heighty=0&amp;width=320&amp;height=286&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\">Åpner opp om</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">sykdommen: - Redd</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Denne går viralt nå\" href=\"https://tinyurl.com/settingspray1?allerID=1202402279\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Denne går viralt nå\" alt=\"Image: Denne går viralt nå\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81125953.jpg?imageId=81125953&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=100.000000&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 glOqqI title dynamic-sizing\">Denne går</span><span class=\"x__pt8tzk-0 jFsmoq title dynamic-sizing\">viralt nå</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></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=\"- Hva i helvete?\" href=\"https://www.dagbladet.no/kjendis/hva-i-helvete/81397135\"><figure class=\"x__sc-1an7vu1-0 YTIkI\"><picture><img data-defer=\"view\" title=\"Image: - Hva i helvete?\" alt=\"Image: - Hva i helvete?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81397323&amp;panoy=39.170506912442&amp;panox=0.067385849056599&amp;panow=99.932614150943&amp;panoh=33.574719815668&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=223&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 egjpuh title dynamic-sizing\">- Hva i</span><span class=\"x__pt8tzk-0 dJenrE title dynamic-sizing\">helvete?</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=\"- Katastrofale konsekvenser\" href=\"https://www.dagbladet.no/nyheter/katastrofale-konsekvenser/81377288\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><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=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 bxtuZJ title dynamic-sizing\">- Katastrofale</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">konsekvenser</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=\"Zelenskyjs to kriger\" href=\"https://www.dagbladet.no/nyheter/zelenskyjs-to-kriger/81345136\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><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=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 hbQXRv title dynamic-sizing\">Zelenskyjs</span><span class=\"x__pt8tzk-0 iWZcdV title dynamic-sizing\">to kriger</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Røper: - Et sjokk\" href=\"https://www.dagbladet.no/kjendis/roper-et-sjokk/81356540\"><figure class=\"x__sc-1an7vu1-0 jbNkVD\"><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=482&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 gLHLEv title dynamic-sizing\">Røper: - Et sjokk</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=\"Flytter «Putins gullgutter»\" href=\"https://www.dagbladet.no/nyheter/flytter-putins-gullgutter/81400163\"><figure class=\"x__sc-1an7vu1-0 gOIzNO\"><picture><img data-defer=\"view\" title=\"Image: Flytter «Putins gullgutter»\" alt=\"Image: Flytter «Putins gullgutter»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80720415&amp;panow=100&amp;panoh=51.063829787234&amp;panoy=7.8014184397163&amp;panox=0&amp;heighty=0&amp;heightx=46.606334841629&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=266&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">Flytter «Putins</span><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">gullgutter»</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\"><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=\"Rystet: Måtte stoppes\" href=\"https://www.dagbladet.no/sport/rystet-matte-stoppes/81398255\"><figure class=\"x__sc-1an7vu1-0 lbczJt\"><picture><img data-defer=\"view\" title=\"Image: Rystet: Måtte stoppes\" alt=\"Image: Rystet: Måtte stoppes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398317&amp;panoy=7.8571428571429&amp;panox=0.16025673076923&amp;panow=100.16025673077&amp;panoh=50.952381428571&amp;heighty=0.22831095890411&amp;heightx=23.394495412844&amp;heightw=40.978593577982&amp;heighth=100.2283109589&amp;width=402&amp;height=281&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 gXQhrg title dynamic-sizing\">Rystet:</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Måtte stoppes</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=\"Derfor bruker Vedum bunad\" href=\"https://www.dagbladet.no/nyheter/derfor-bruker-vedum-bunad/81403438\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Derfor bruker Vedum bunad\" alt=\"Image: Derfor bruker Vedum bunad\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81403448&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 hQxAYP title dynamic-sizing\">Derfor bruker</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">Vedum bunad</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=\"Linn (33) fikk sjokkbeskjed: Advarer\" href=\"https://www.dagbladet.no/tema/linn-33-fikk-sjokkbeskjed-advarer/81263652\"><figure class=\"x__sc-1an7vu1-0 jqAWdU\"><picture><img data-defer=\"view\" title=\"Image: Linn (33) fikk sjokkbeskjed: Advarer\" alt=\"Image: Linn (33) fikk sjokkbeskjed: Advarer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302345&amp;panox=33.333333333333&amp;panow=29.518835042735&amp;panoh=66.878306666667&amp;panoy=18.095238095238&amp;heighty=0.15325655172413&amp;heightx=45.407098121086&amp;heightw=9.31338434238&amp;heighth=100.15325655172&amp;width=320&amp;height=235&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Linn (33) fikk</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">sjokkbeskjed: Advarer</span></h3></header></a></article><article class=\"preview columns small-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-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=\"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 fnQDHb\"><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=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 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><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=\"Om kjæresten: - Er ikke «skjuling»\" href=\"https://www.dagbladet.no/sport/om-kjaeresten-er-ikke-skjuling/81372449\"><figure class=\"x__sc-1an7vu1-0 cQSpuk\"><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=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 jiGVVj title dynamic-sizing\">Om kjæresten: - Er</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">ikke «skjuling»</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=\"Deler gladnyhet\" href=\"https://www.dagbladet.no/kjendis/deler-gladnyhet/81398639\"><figure class=\"x__sc-1an7vu1-0 cIfcrt\"><picture><img data-defer=\"view\" title=\"Image: Deler gladnyhet\" alt=\"Image: Deler gladnyhet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81254259&amp;panoy=0&amp;panow=100&amp;panoh=50.714285714286&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=274&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">Deler gladnyhet</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å utsette\" href=\"https://www.dagbladet.no/kjendis/ma-utsette/81400870\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Må utsette\" alt=\"Image: Må utsette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81400890&amp;panoy=41.428571428571&amp;panow=100&amp;panoh=25.357142857143&amp;panox=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&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 iAWFly title dynamic-sizing\">Må utsette</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"De er sønnene\" href=\"https://www.dagbladet.no/video/de-er-sonnene/0WIF6AwQ\"><figure class=\"x__sc-1an7vu1-0 iRrFGC\"><picture><img data-defer=\"view\" title=\"Image: De er sønnene\" alt=\"Image: De er sønnene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/0WIF6AwQ-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\">De er sønnene</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=\"Ufrivillig singel? Sex-garanti\" href=\"https://www.dagbladet.no/tema/ufrivillig-singel-sex-garanti/81395739\"><figure class=\"x__sc-1an7vu1-0 iRrFGC\"><picture><img data-defer=\"view\" title=\"Image: Ufrivillig singel? Sex-garanti\" alt=\"Image: Ufrivillig singel? Sex-garanti\" 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=174&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 fIeyCx title dynamic-sizing\">Sex-garanti</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=\"Latterliggjør anklager\" href=\"https://www.dagbladet.no/kjendis/latterliggjor-anklager/81398124\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Latterliggjør anklager\" alt=\"Image: Latterliggjør anklager\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81391438&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=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 dUqYKO title dynamic-sizing\">Latterliggjør</span><span class=\"x__pt8tzk-0 fYNSni title dynamic-sizing\">anklager</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=\"Tar grep på 17. mai: - Kaotisk\" href=\"https://www.dagbladet.no/kjendis/tar-grep-pa-17-mai-kaotisk/81395022\"><figure class=\"x__sc-1an7vu1-0 ilNZJn\"><picture><img data-defer=\"view\" title=\"Image: Tar grep på 17. mai: - Kaotisk\" alt=\"Image: Tar grep på 17. mai: - Kaotisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81393892&amp;panow=68.181818181818&amp;panoy=18.5&amp;panox=7.1428571428571&amp;panoh=35.323383084577&amp;heightx=25.964912280702&amp;heightw=31.578947368421&amp;heighth=79.032258064516&amp;heighty=8.0645161290323&amp;width=402&amp;height=410&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\">Tar grep på 17.</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">mai: - Kaotisk</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=\"Raser mot rykter\" href=\"https://www.dagbladet.no/sport/raser-mot-rykter/81377329\"><figure class=\"x__sc-1an7vu1-0 fwaYEb\"><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=402&amp;height=498&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\">Raser mot rykter</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=\"Oppdaget giga-hull\" href=\"https://www.dagbladet.no/nyheter/oppdaget-giga-hull/81393433\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Oppdaget giga-hull\" alt=\"Image: Oppdaget giga-hull\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81394106&amp;panox=42.545616377392&amp;panow=22.096128170895&amp;panoh=18.49768365321&amp;panoy=36.962276637988&amp;heighty=36.962276637988&amp;heightx=42.545616377392&amp;heightw=22.096128170895&amp;heighth=18.49768365321&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 kkHfrE title dynamic-sizing\">Oppdaget</span><span class=\"x__pt8tzk-0 iEukpb title dynamic-sizing\">giga-hull</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 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=\"Teipen sparer deg for tusenlapper\" href=\"https://www.dagbladet.no/video/teipen-sparer-deg-for-tusenlapper/cQzJlZ02\"><figure class=\"x__sc-1an7vu1-0 ejHyWU moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Teipen sparer deg for tusenlapper\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/79262736.jpg?imageId=79262736&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=204\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/05/11/8c1b0bbb-c5f5-4cb3-b45a-0f02f6306f7e/gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/05/11/8c1b0bbb-c5f5-4cb3-b45a-0f02f6306f7e/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 BsLeO title dynamic-sizing\">Teipen sparer deg</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">for tusenlapper</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=\"Supergrepene mot neglesopp: Billig og effektivt!\" href=\"https://www.dagbladet.no/tema/supergrepene-mot-neglesopp-billig-og-effektivt/81328715\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Supergrepene mot neglesopp: Billig og effektivt!\" alt=\"Image: Supergrepene mot neglesopp: Billig og effektivt!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335659&amp;panoy=15.328467153285&amp;panox=0&amp;panow=100&amp;panoh=51.094890510949&amp;heightw=40.93023255814&amp;heighth=100&amp;heightx=3.7209302325581&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 zWscE title dynamic-sizing\">Supergrepene mot</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">neglesopp: Billig</span><span class=\"x__pt8tzk-0 jXDBAT title dynamic-sizing\">og effektivt!</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=\"Raseri etter OL-nekt\" href=\"https://www.dagbladet.no/sport/raseri-etter-ol-nekt/81395462\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Raseri etter OL-nekt\" alt=\"Image: Raseri etter OL-nekt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335191&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=45.714285714286&amp;heighty=0&amp;heightx=47.058823529412&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 dWzMnA title dynamic-sizing\">Raseri etter</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">OL-nekt</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=\"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 dFQuBj\"><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=485&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 dBWQRi title dynamic-sizing\">Cohen klar for</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">å avsløre Trump</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bekrefter endring i planene\" href=\"https://www.dagbladet.no/sport/bekrefter-endring-i-planene/81396120\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><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=402&amp;height=201&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 criDNb title dynamic-sizing\">Bekrefter</span><span class=\"x__pt8tzk-0 cVlLEd title dynamic-sizing\">endring i planene</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=\"Ferdig etterforsket\" href=\"https://www.dagbladet.no/kjendis/ferdig-etterforsket/81396293\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><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=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\">Ferdig etterforsket</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard7\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Øyekrem-test: To får toppscore!\" href=\"https://www.dagbladet.no/tema/oyekrem-test-to-far-toppscore/81186636\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Øyekrem-test: To får toppscore!\" alt=\"Image: Øyekrem-test: To får toppscore!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81229808&amp;panoy=30.48128342246&amp;panow=100&amp;panoh=38.502673796791&amp;panox=0&amp;heighty=0&amp;heightx=15.66265060241&amp;heightw=54.21686746988&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\">Øyekrem-test: To</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">får toppscore!</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=\"- Putins siste advarsel\" href=\"https://www.dagbladet.no/video/-putins-siste-advarsel/cv7eoP10\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Putins siste advarsel\" alt=\"Image: - Putins siste advarsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/cv7eoP10-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 fFAiTK title dynamic-sizing\">- Putins</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">siste advarsel</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=\"Derfor forsvant han\" href=\"https://www.dagbladet.no/sport/derfor-forsvant-han/81394722\"><figure class=\"x__sc-1an7vu1-0 isdgsy\"><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=485&amp;height=400&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 wpWLG title dynamic-sizing\">Derfor forsvant han</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=\"Klappjakt på «Fluen»\" href=\"https://www.dagbladet.no/nyheter/klappjakt-pa-fluen/81402571\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Klappjakt på «Fluen»\" alt=\"Image: Klappjakt på «Fluen»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81402653&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=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 eVVsXT title dynamic-sizing\">Klappjakt</span><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">på «Fluen»</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=\"Bekrefter forhold til kvinne\" href=\"https://www.dagbladet.no/video/bekrefter-forhold-til-kvinne/7J57eCOv\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter forhold til kvinne\" alt=\"Image: Bekrefter forhold til kvinne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/7J57eCOv-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\">Bekrefter forhold</span><span class=\"x__pt8tzk-0 bkgkdp title dynamic-sizing\">til kvinne</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=\"AFP-fella: 1,3 mill mindre\" href=\"https://www.dagbladet.no/tema/afp-fella-13-mill-mindre/81275737\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><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=164&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 ivnriz title dynamic-sizing\">mill mindre</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=\"Dukket opp nye bevis\" href=\"https://www.dagbladet.no/nyheter/dukket-opp-nye-bevis/81400199\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dukket opp nye bevis\" alt=\"Image: Dukket opp nye bevis\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81400481&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ldTjgH title dynamic-sizing\">Dukket opp</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">nye bevis</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=\"Én uteblir\" href=\"https://www.dagbladet.no/kjendis/en-uteblir/81393761\"><figure class=\"x__sc-1an7vu1-0 cCuzIK\"><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=402&amp;height=438&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\">Én uteblir</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard8\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Minus 17 kilo raskt\" href=\"https://www.dagbladet.no/tema/nicoles-ene-grep-ned-17-kilo/81344867\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Minus 17 kilo raskt\" alt=\"Image: Minus 17 kilo raskt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81349525&amp;panoy=0&amp;panox=40.920938314509&amp;panow=17.897480451781&amp;panoh=67.307692307692&amp;heighty=0&amp;heightx=47&amp;heightw=5.4906542056075&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 dBWQRi title dynamic-sizing\">Minus 17</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">kilo raskt</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=\"Spesialstyrkene slår til i Russland\" href=\"https://www.dagbladet.no/video/spesialstyrkene-slar-til-i-russland/K0H9fmiZ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Spesialstyrkene slår til i Russland\" alt=\"Image: Spesialstyrkene slår til i Russland\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/K0H9fmiZ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Spesialstyrkene</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">slår til i Russland</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dro til legen - fant dette\" href=\"https://www.dagbladet.no/video/dro-til-legen-fant-dette/1gFyPrJZ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Dro til legen - fant dette\" alt=\"Image: Dro til legen - fant dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/1gFyPrJZ-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\">Dro til legen</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">- fant dette</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer mot matvarer: Gir uren hud \" href=\"https://www.dagbladet.no/tema/advarer-mot-matvarer-gir-uren-hud/81273523\"><figure class=\"x__sc-1an7vu1-0 kLZUyf\"><picture><img data-defer=\"view\" title=\"Image: Advarer mot matvarer: Gir uren hud \" alt=\"Image: Advarer mot matvarer: Gir uren hud \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342684&amp;panox=0&amp;panow=100&amp;panoh=51.094890510949&amp;panoy=14.598540145985&amp;heighth=100&amp;heighty=0&amp;heightx=46.976744186047&amp;heightw=40.93023255814&amp;width=320&amp;height=195&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\">Advarer mot matvarer:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Gir uren hud </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=\"Totalslakt: - Sjokkerende\" href=\"https://www.dagbladet.no/sport/totalslakt-sjokkerende/81393182\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><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=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\">Totalslakt:</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">- Sjokkerende</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"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 hTZISu\"><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=485&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 cVlLEd title dynamic-sizing\">Røykteppe velter inn:</span><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">- Svært helseskadelig</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Høytrykkspyler-vinner: - Gjør rent bord!\" href=\"https://www.dagbladet.no/tema/hoytrykkspyler-vinner-gjor-rent-bord/81067765\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Høytrykkspyler-vinner: - Gjør rent bord!\" alt=\"Image: Høytrykkspyler-vinner: - Gjør rent bord!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75958864&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Høytrykkspyler-vinner:</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">- Gjør rent bord!</span></h3></header></a></article><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=\"Blankt på et blunk!\" href=\"https://www.dagbladet.no/video/-blir-sa-blankt-og-fint/UfvTgJXV\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Blankt på et blunk!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/79294695.jpg?imageId=79294695&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/15/ede60300-6516-4b19-9b9e-19fe12d81cab/gif_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/05/15/ede60300-6516-4b19-9b9e-19fe12d81cab/gif_2.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 iLHueX title dynamic-sizing\">Blankt på</span><span class=\"x__pt8tzk-0 cnjOqe title dynamic-sizing\">et blunk!</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=\"- Ansvarsløst\" href=\"https://www.dagbladet.no/kjendis/ansvarslost/81374616\"><figure class=\"x__sc-1an7vu1-0 bcRKOI\"><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=402&amp;height=388&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\">- Ansvarsløst</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=\"- Starten på Russlands offensiv\" href=\"https://www.dagbladet.no/nyheter/starten-pa-russlands-offensiv/81393843\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Starten på Russlands offensiv\" alt=\"Image: - Starten på Russlands offensiv\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81397363&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=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 gNDiBf title dynamic-sizing\">- Starten på</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">Russlands offensiv</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=\"Ny flause fra presidenten\" href=\"https://www.dagbladet.no/video/ny-flause-fra-presidenten/xB6HkcR4\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ny flause fra presidenten\" alt=\"Image: Ny flause fra presidenten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/xB6HkcR4-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\">Ny flause fra</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">presidenten</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=\"Mathias viser kroppen: - Det indre som teller\" href=\"https://www.dagbladet.no/tema/mathias-viser-kroppen-det-indre-som-teller/81363702\"><figure class=\"x__sc-1an7vu1-0 gkSegO\"><picture><img data-defer=\"view\" title=\"Image: Mathias viser kroppen: - Det indre som teller\" alt=\"Image: Mathias viser kroppen: - Det indre som teller\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398168&amp;panoy=41.525423728814&amp;panox=0&amp;panow=100&amp;panoh=15.677966101695&amp;heightw=43.720930232558&amp;heighth=32.832618025751&amp;heighty=39.484978540773&amp;heightx=36.744186046512&amp;width=320&amp;height=211&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\">Mathias viser kroppen:</span><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">- Det indre som teller</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=\"Nekter drap på Emilie Meng\" href=\"https://www.dagbladet.no/nyheter/nekter-drap-pa-emilie-meng/81399611\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Nekter drap på Emilie Meng\" alt=\"Image: Nekter drap på Emilie Meng\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81398815&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=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 gNDiBf title dynamic-sizing\">Nekter drap</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">på Emilie Meng</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 cjSQRT\"><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=326&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\"><div id=\"apos-netboard10\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard10\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"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 fjJyvE\"><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=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">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-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 «hele» Norge så\" href=\"https://www.dagbladet.no/video/bildene-hele-norge-sa/eMUs8yPN\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Bildene «hele» Norge så\" alt=\"Image: Bildene «hele» Norge så\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/eMUs8yPN-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\">Bildene «hele»</span><span class=\"x__pt8tzk-0 bHxiDg title dynamic-sizing\">Norge så</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Jagerflyet går i lufta\" href=\"https://www.dagbladet.no/video/jagerflyet-gar-i-lufta/qocxhxds\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Jagerflyet går i lufta\" alt=\"Image: Jagerflyet går i lufta\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/qocxhxds-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 glOqqI title dynamic-sizing\">Jagerflyet</span><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">går i lufta</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Atopisk eksem kobles til alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/studie-kobler-atopisk-eksem-til-kronisk-sykdom/81334619\"><figure class=\"x__sc-1an7vu1-0 fgisev\"><picture><img data-defer=\"view\" title=\"Image: Atopisk eksem kobles til alvorlig sykdom\" alt=\"Image: Atopisk eksem kobles til alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80197278&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=231&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Atopisk eksem kobles</span><span class=\"x__pt8tzk-0 jkoItf title dynamic-sizing\">til alvorlig sykdom</span></h3></header></a></article><div id=\"apos-medium-rectangle9\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard11\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Angst: Slik får du uføretrygd\" href=\"https://www.dagbladet.no/tema/angst-slik-far-du-uforetrygd/81395578\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Angst: Slik får du uføretrygd\" alt=\"Image: Angst: Slik får du uføretrygd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81395620&amp;panow=100.16181553398&amp;panoh=56.266672&amp;panoy=13.6&amp;panox=0.16181553398058&amp;heighty=0.23310489510489&amp;heightx=38.983050847458&amp;heightw=37.005652542373&amp;heighth=100.2331048951&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 jdgMzU title dynamic-sizing\">Angst: Slik får</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">du uføretrygd</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><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=\"Sjokk-avvisning i «Gift ved første blikk»\" href=\"https://www.dagbladet.no/video/sjokk-avvisning-i-gift-ved-forste-blikk/B5ytwnxe\"><figure class=\"x__sc-1an7vu1-0 ebIGPt\"><picture><img data-defer=\"view\" title=\"Image: Sjokk-avvisning i «Gift ved første blikk»\" alt=\"Image: Sjokk-avvisning i «Gift ved første blikk»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/B5ytwnxe-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Sjokk-avvisning</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">i «Gift ved</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">første blikk»</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=\"Overlegens lynmetode: Ned åtte kilo\" href=\"https://www.dagbladet.no/tema/overlegens-lynmetode-ned-atte-kilo/81366111\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Overlegens lynmetode: Ned åtte kilo\" alt=\"Image: Overlegens lynmetode: Ned åtte kilo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81368069&amp;panoy=17.309381443299&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=36.483391752577&amp;heighth=99.847794520548&amp;heighty=0&amp;heightx=19.745222929936&amp;heightw=57.183299363057&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 kYsbxS title dynamic-sizing\">Overlegens</span><span class=\"x__pt8tzk-0 ivnriz title dynamic-sizing\">lynmetode:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Ned åtte kilo</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 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=\"«Pappa har skrevet noe dumt»\" href=\"https://www.dagbladet.no/tema/snakker-ut-om-whisky-innleggene/81251334\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: «Pappa har skrevet noe dumt»\" alt=\"Image: «Pappa har skrevet noe dumt»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81251351&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">«Pappa har</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">skrevet noe dumt»</span></h3></header></a></article></div></div><div id=\"apos-netboard12\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard12&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Her avsløres Trumps sønn\" href=\"https://www.dagbladet.no/video/her-avslores-trumps-sonn/cnTjfR3x\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Her avsløres Trumps sønn\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81392378.jpg?imageId=81392378&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/13/027bcc68-d902-4d26-a086-d5334a7bd7fb/gif_trumps_soenn.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/13/027bcc68-d902-4d26-a086-d5334a7bd7fb/gif_trumps_soenn.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 dAsdTT title dynamic-sizing\">Her avsløres</span><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">Trumps sønn</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=\"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 kuSVct\"><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=194&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\">Sjøgrens: Ta disse</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">tegnene på alvor</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>"]