-
Nødetatene rykker ut til fly med problemer
-
Snøskred i Troms - sikker på at ingen er tatt
-
Trondheim: Evakuerer bygg etter brann
-
Russland: Fireåring skal være funnet død i vaskemaskin
-
Trafikkulykke: Hest inni hengeren
-
Ring 3 åpen for trafikk i alle felt
-
Lagt i bakken av opprørspoliti
-
Starter våpenhvile-forhandlinger
-
Kreml: Truer Vesten med alvorlige reaksjoner
-
Person pågrepet etter vold i Harstad
["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .iYLNuD.iYLNuD.iYLNuD.iYLNuD{height:0;padding-bottom:56.7%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .dMEOmz.dMEOmz.dMEOmz.dMEOmz{height:0;padding-bottom:52.16%;}/*!sc*/ .eIlDNY.eIlDNY.eIlDNY.eIlDNY{height:0;padding-bottom:51.56%;}/*!sc*/ .gjAolr.gjAolr.gjAolr.gjAolr{height:0;padding-bottom:53.75%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .cpgbup.cpgbup.cpgbup.cpgbup{height:0;padding-bottom:70.89%;}/*!sc*/ .hpZPQm.hpZPQm.hpZPQm.hpZPQm{height:0;padding-bottom:68.65%;}/*!sc*/ .kPAogU.kPAogU.kPAogU.kPAogU{height:0;padding-bottom:64.94%;}/*!sc*/ .hIDOUr.hIDOUr.hIDOUr.hIDOUr{height:0;padding-bottom:59.95%;}/*!sc*/ .gIetcv.gIetcv.gIetcv.gIetcv{height:0;padding-bottom:61.56%;}/*!sc*/ .krHhho.krHhho.krHhho.krHhho{height:0;padding-bottom:54.02%;}/*!sc*/ .gaapxn.gaapxn.gaapxn.gaapxn{height:0;padding-bottom:62.26%;}/*!sc*/ .dmGuJR.dmGuJR.dmGuJR.dmGuJR{height:0;padding-bottom:84.57%;}/*!sc*/ .ioubUL.ioubUL.ioubUL.ioubUL{height:0;padding-bottom:80.59%;}/*!sc*/ .dystQj.dystQj.dystQj.dystQj{height:0;padding-bottom:67.81%;}/*!sc*/ .iFCyIa.iFCyIa.iFCyIa.iFCyIa{height:0;padding-bottom:56.46%;}/*!sc*/ .cRGFeD.cRGFeD.cRGFeD.cRGFeD{height:0;padding-bottom:127.11%;}/*!sc*/ .eMbtnT.eMbtnT.eMbtnT.eMbtnT{height:0;padding-bottom:52.78%;}/*!sc*/ .kDkkya.kDkkya.kDkkya.kDkkya{height:0;padding-bottom:51.49%;}/*!sc*/ .idKCHs.idKCHs.idKCHs.idKCHs{height:0;padding-bottom:50.93%;}/*!sc*/ .aqCCR.aqCCR.aqCCR.aqCCR{height:0;padding-bottom:52.5%;}/*!sc*/ .jJPOlH.jJPOlH.jJPOlH.jJPOlH{height:0;padding-bottom:70.3%;}/*!sc*/ .jjcUMQ.jjcUMQ.jjcUMQ.jjcUMQ{height:0;padding-bottom:58.35%;}/*!sc*/ .btjLaZ.btjLaZ.btjLaZ.btjLaZ{height:0;padding-bottom:97.26%;}/*!sc*/ .iMoPFf.iMoPFf.iMoPFf.iMoPFf{height:0;padding-bottom:79.35%;}/*!sc*/ .iRrFGC.iRrFGC.iRrFGC.iRrFGC{height:0;padding-bottom:54.37%;}/*!sc*/ .lcWYHB.lcWYHB.lcWYHB.lcWYHB{height:0;padding-bottom:63.12%;}/*!sc*/ .gQoIpx.gQoIpx.gQoIpx.gQoIpx{height:0;padding-bottom:69.27%;}/*!sc*/ .hygKBp.hygKBp.hygKBp.hygKBp{height:0;padding-bottom:63.43%;}/*!sc*/ .ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .faiitY.faiitY.faiitY.faiitY{height:0;padding-bottom:86.18%;}/*!sc*/ .gmpxUf.gmpxUf.gmpxUf.gmpxUf{height:0;padding-bottom:55.62%;}/*!sc*/ .ixaLcU.ixaLcU.ixaLcU.ixaLcU{height:0;padding-bottom:63.93%;}/*!sc*/ .jDKzJI.jDKzJI.jDKzJI.jDKzJI{height:0;padding-bottom:74.37%;}/*!sc*/ .fYvkjy.fYvkjy.fYvkjy.fYvkjy{height:0;padding-bottom:67.62%;}/*!sc*/ .dPlQCr.dPlQCr.dPlQCr.dPlQCr{height:0;padding-bottom:65.92%;}/*!sc*/ .fpAqZR.fpAqZR.fpAqZR.fpAqZR{height:0;padding-bottom:99.68%;}/*!sc*/ .bLPPUH.bLPPUH.bLPPUH.bLPPUH{height:0;padding-bottom:93.28%;}/*!sc*/ .jyPXHD.jyPXHD.jyPXHD.jyPXHD{height:0;padding-bottom:75.93%;}/*!sc*/ .iPjCRj.iPjCRj.iPjCRj.iPjCRj{height:0;padding-bottom:68.75%;}/*!sc*/ .dAklYm.dAklYm.dAklYm.dAklYm{height:0;padding-bottom:62.81%;}/*!sc*/ data-styled.g367[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,iYLNuD,fnQDHb,dMEOmz,eIlDNY,gjAolr,kviAry,cpgbup,hpZPQm,kPAogU,hIDOUr,gIetcv,krHhho,gaapxn,dmGuJR,ioubUL,dystQj,iFCyIa,cRGFeD,eMbtnT,kDkkya,idKCHs,aqCCR,jJPOlH,jjcUMQ,btjLaZ,iMoPFf,iRrFGC,lcWYHB,gQoIpx,hygKBp,ejnyBo,faiitY,gmpxUf,ixaLcU,jDKzJI,fYvkjy,dPlQCr,fpAqZR,bLPPUH,jyPXHD,iPjCRj,dAklYm,\"}/*!sc*/ .cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:0.8em!important;}}/*!sc*/ .frzFun.frzFun.frzFun.frzFun{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.frzFun.frzFun.frzFun.frzFun{font-size:0.9em!important;}}/*!sc*/ .cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:1.5em!important;}}/*!sc*/ .jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:1.8em!important;}}/*!sc*/ .kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:2.2em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .cKEAmr.cKEAmr.cKEAmr.cKEAmr{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.cKEAmr.cKEAmr.cKEAmr.cKEAmr{font-size:0.6em!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*/ .jPnLUB.jPnLUB.jPnLUB.jPnLUB{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jPnLUB.jPnLUB.jPnLUB.jPnLUB{font-size:2.3em!important;}}/*!sc*/ .btuFCM.btuFCM.btuFCM.btuFCM{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.btuFCM.btuFCM.btuFCM.btuFCM{font-size:1.7em!important;}}/*!sc*/ .hAncxD.hAncxD.hAncxD.hAncxD{font-size:7.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.hAncxD.hAncxD.hAncxD.hAncxD{font-size:2.8em!important;}}/*!sc*/ .fFAiTK.fFAiTK.fFAiTK.fFAiTK{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.fFAiTK.fFAiTK.fFAiTK.fFAiTK{font-size:1.9em!important;}}/*!sc*/ .ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:1.7em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .kxzaKl.kxzaKl.kxzaKl.kxzaKl{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.kxzaKl.kxzaKl.kxzaKl.kxzaKl{font-size:1em!important;}}/*!sc*/ .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*/ .fDxrvm.fDxrvm.fDxrvm.fDxrvm{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.fDxrvm.fDxrvm.fDxrvm.fDxrvm{font-size:2.7em!important;}}/*!sc*/ .bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:1.5em!important;}}/*!sc*/ .erpCho.erpCho.erpCho.erpCho{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.erpCho.erpCho.erpCho.erpCho{font-size:1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:0.9em!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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:2.8em!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*/ .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*/ .beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:0.6em!important;}}/*!sc*/ .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*/ .hbwikt.hbwikt.hbwikt.hbwikt{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.hbwikt.hbwikt.hbwikt.hbwikt{font-size:2.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .bUEFlv.bUEFlv.bUEFlv.bUEFlv{font-size:1.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bUEFlv.bUEFlv.bUEFlv.bUEFlv{font-size:0.5em!important;}}/*!sc*/ .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*/ .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*/ .bSlVPf.bSlVPf.bSlVPf.bSlVPf{font-size:10em!important;}/*!sc*/ @media only screen and (max-width:640px){.bSlVPf.bSlVPf.bSlVPf.bSlVPf{font-size:3.5em!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*/ .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*/ .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*/ .iCwWtY.iCwWtY.iCwWtY.iCwWtY{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iCwWtY.iCwWtY.iCwWtY.iCwWtY{font-size:1.5em!important;}}/*!sc*/ .iCqzVN.iCqzVN.iCqzVN.iCqzVN{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iCqzVN.iCqzVN.iCqzVN.iCqzVN{font-size:2.1em!important;}}/*!sc*/ .jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .dLwqhJ.dLwqhJ.dLwqhJ.dLwqhJ{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dLwqhJ.dLwqhJ.dLwqhJ.dLwqhJ{font-size:1.4em!important;}}/*!sc*/ .hOOMjn.hOOMjn.hOOMjn.hOOMjn{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.hOOMjn.hOOMjn.hOOMjn.hOOMjn{font-size:2.7em!important;}}/*!sc*/ .gALHSm.gALHSm.gALHSm.gALHSm{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.gALHSm.gALHSm.gALHSm.gALHSm{font-size:1.9em!important;}}/*!sc*/ .jCkLvS.jCkLvS.jCkLvS.jCkLvS{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jCkLvS.jCkLvS.jCkLvS.jCkLvS{font-size:2.6em!important;}}/*!sc*/ .iNHyie.iNHyie.iNHyie.iNHyie{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.iNHyie.iNHyie.iNHyie.iNHyie{font-size:0.7em!important;}}/*!sc*/ .bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:1.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .cKlSIC.cKlSIC.cKlSIC.cKlSIC{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cKlSIC.cKlSIC.cKlSIC.cKlSIC{font-size:1.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*/ .hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:1.8em!important;}}/*!sc*/ .kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:0.7em!important;}}/*!sc*/ .gRLJwN.gRLJwN.gRLJwN.gRLJwN{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gRLJwN.gRLJwN.gRLJwN.gRLJwN{font-size:1.8em!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*/ .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*/ .hpQSgl.hpQSgl.hpQSgl.hpQSgl{font-size:1.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.hpQSgl.hpQSgl.hpQSgl.hpQSgl{font-size:0.5em!important;}}/*!sc*/ .bWzzkU.bWzzkU.bWzzkU.bWzzkU{font-size:7.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bWzzkU.bWzzkU.bWzzkU.bWzzkU{font-size:2.6em!important;}}/*!sc*/ .kVcwCb.kVcwCb.kVcwCb.kVcwCb{font-size:8.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kVcwCb.kVcwCb.kVcwCb.kVcwCb{font-size:3em!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*/ .fjKRAi.fjKRAi.fjKRAi.fjKRAi{font-size:1.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fjKRAi.fjKRAi.fjKRAi.fjKRAi{font-size:0.6em!important;}}/*!sc*/ .ioa-DgC.ioa-DgC.ioa-DgC.ioa-DgC{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.ioa-DgC.ioa-DgC.ioa-DgC.ioa-DgC{font-size:1.4em!important;}}/*!sc*/ .cCIJgC.cCIJgC.cCIJgC.cCIJgC{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.cCIJgC.cCIJgC.cCIJgC.cCIJgC{font-size:1.3em!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*/ .kAKGGI.kAKGGI.kAKGGI.kAKGGI{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kAKGGI.kAKGGI.kAKGGI.kAKGGI{font-size:2.5em!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*/ .iYgBvA.iYgBvA.iYgBvA.iYgBvA{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.iYgBvA.iYgBvA.iYgBvA.iYgBvA{font-size:0.8em!important;}}/*!sc*/ .iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:1em!important;}}/*!sc*/ .iyrywY.iyrywY.iyrywY.iyrywY{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.iyrywY.iyrywY.iyrywY.iyrywY{font-size:1.8em!important;}}/*!sc*/ .bFQuDG.bFQuDG.bFQuDG.bFQuDG{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bFQuDG.bFQuDG.bFQuDG.bFQuDG{font-size:1.9em!important;}}/*!sc*/ .jfhrCI.jfhrCI.jfhrCI.jfhrCI{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfhrCI.jfhrCI.jfhrCI.jfhrCI{font-size:1.2em!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*/ .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*/ .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*/ .hIOHzH.hIOHzH.hIOHzH.hIOHzH{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.hIOHzH.hIOHzH.hIOHzH.hIOHzH{font-size:2.3em!important;}}/*!sc*/ .fopCi.fopCi.fopCi.fopCi{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.fopCi.fopCi.fopCi.fopCi{font-size:0.9em!important;}}/*!sc*/ .ihkPAv.ihkPAv.ihkPAv.ihkPAv{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.ihkPAv.ihkPAv.ihkPAv.ihkPAv{font-size:0.8em!important;}}/*!sc*/ .jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:1.3em!important;}}/*!sc*/ data-styled.g368[id=\"x__pt8tzk-0\"]{content:\"cyVXzf,frzFun,cJcNIn,jtCXvA,kyzRFP,iAWFly,jdcGMN,dBWQRi,fNDhDy,gjHDge,cKEAmr,dJenrE,jPnLUB,btuFCM,hAncxD,fFAiTK,ftetSQ,kNhGgX,hsPeia,BsLeO,kxzaKl,iLHueX,fDxrvm,bNRoJL,erpCho,dWzMnA,iXjdLY,jdgMzU,jfvMWJ,cnaKkM,dyaAfc,inksEV,epoJzD,ijicdz,emaxbb,gPIxea,ggbHpa,LzBnW,jRIgeY,beDNpZ,gVRWAB,hbwikt,dfserP,kauVAS,bwzwBX,kkHfrE,bUEFlv,bkgkdp,kMqJSM,bSlVPf,kUqUJf,bWSnVS,dfgvpn,iCwWtY,iCqzVN,jGSTdz,cFtCN,kVJNPR,dLwqhJ,hOOMjn,gALHSm,jCkLvS,iNHyie,bwGQrt,cZmotM,hrVcDN,bxtuZJ,cKlSIC,gLHLEv,hPDIHE,kwLuaB,gRLJwN,gNDiBf,wpWLG,hpQSgl,bWzzkU,kVcwCb,hQxAYP,fjKRAi,ioa-DgC,cCIJgC,iWZcdV,kAKGGI,tqGkg,iYgBvA,iFlEmK,iyrywY,bFQuDG,jfhrCI,lfBuL,ivnriz,jiGVVj,hIOHzH,fopCi,ihkPAv,jIyTDK,\"}/*!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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bildene går verden rundt - kastes ut\" href=\"https://www.dagbladet.no/video/bildene-gar-verden-rundt-kastes-ut/nQLq2Wal\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Bildene går verden rundt - kastes ut\" alt=\"Image: Bildene går verden rundt - kastes ut\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/nQLq2Wal-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Bildene går verden</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">rundt - kastes ut</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=\"Åpner om livsvalget\" href=\"https://www.dagbladet.no/kjendis/apner-om-livsvalget/81058620\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Åpner om livsvalget\" alt=\"Image: Åpner om livsvalget\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81058645&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 cJcNIn title dynamic-sizing\">Åpner om</span><span class=\"x__pt8tzk-0 cJcNIn title dynamic-sizing\">livsvalget</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=\"Syreforgiftet - på sykehus\" href=\"https://www.dagbladet.no/kjendis/syreforgiftet-pa-sykehus/81325934\"><figure class=\"x__sc-1an7vu1-0 iYLNuD\"><picture><img data-defer=\"view\" title=\"Image: Syreforgiftet - på sykehus\" alt=\"Image: Syreforgiftet - på sykehus\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81325937&amp;panoh=51.536642553191&amp;panoy=11.347517730496&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=275&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Syreforgiftet</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">- på sykehus</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=\"- Alvorlige reaksjoner\" href=\"https://www.dagbladet.no/nyheter/alvorlige-reaksjoner/81325249\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Alvorlige reaksjoner\" alt=\"Image: - Alvorlige reaksjoner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81325238&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 kyzRFP title dynamic-sizing\">- Alvorlige</span><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">reaksjoner</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=\"Røper forlovelse\" href=\"https://www.dagbladet.no/kjendis/roper-forlovelse/81325640\"><figure class=\"x__sc-1an7vu1-0 dMEOmz\"><picture><img data-defer=\"view\" title=\"Image: Røper forlovelse\" alt=\"Image: Røper forlovelse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81325612&amp;panow=100&amp;panoy=28.897338403042&amp;panoh=26.996197718631&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=485&amp;height=253&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\">Røper forlovelse</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=\"Sårt for Jakob\" href=\"https://www.dagbladet.no/sport/sart-for-jakob/81309563\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Sårt for Jakob\" alt=\"Image: Sårt for Jakob\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80808901&amp;panoy=38.297872340426&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.536642553191&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 dBWQRi title dynamic-sizing\">Sårt for Jakob</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=\"Kari: - Ekstremt uattraktive menn\" href=\"https://www.dagbladet.no/tema/kari-ekstremt-uattraktive-menn/81319789\"><figure class=\"x__sc-1an7vu1-0 eIlDNY\"><picture><img data-defer=\"view\" title=\"Image: Kari: - Ekstremt uattraktive menn\" alt=\"Image: Kari: - Ekstremt uattraktive menn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81321453&amp;panow=100&amp;panoh=100&amp;panox=0&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=165&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Kari: - Ekstremt</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">uattraktive menn</span></h3></header></a></article><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=\"Nabokrangel går verden rundt: - Grusomt\" href=\"https://www.dagbladet.no/video/nabokrangelen-gar-verden-rundt-/7yIhFGgc\"><figure class=\"x__sc-1an7vu1-0 gjAolr moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Nabokrangel går verden rundt: - Grusomt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81322787.jpg?imageId=81322787&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=172\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/26/a9bbfc0f-f0e5-45a5-bcd9-713c62e3adc5/gifslasskamp1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/26/a9bbfc0f-f0e5-45a5-bcd9-713c62e3adc5/gifslasskamp1.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 cKEAmr title dynamic-sizing\">Nabokrangel går verden</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">rundt: - Grusomt</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=\"Husker ikke barnas navn\" href=\"https://www.dagbladet.no/kjendis/husker-ikke-barnas-navn/81316825\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Husker ikke barnas navn\" alt=\"Image: Husker ikke barnas navn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81314477&amp;panoy=10.725552050473&amp;panox=0&amp;panow=100&amp;panoh=22.712933753943&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 dJenrE title dynamic-sizing\">Husker ikke</span><span class=\"x__pt8tzk-0 jPnLUB title dynamic-sizing\">barnas navn</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=\"Ukjent brev avslørt\" href=\"https://www.dagbladet.no/sport/ukjent-brev-avslort/81324379\"><figure class=\"x__sc-1an7vu1-0 cpgbup\"><picture><img data-defer=\"view\" title=\"Image: Ukjent brev avslørt\" alt=\"Image: Ukjent brev avslørt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324387&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=16.428571428571&amp;panox=0&amp;heighty=0&amp;heightx=41.818181818182&amp;heightw=40.909090909091&amp;heighth=100&amp;width=402&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 btuFCM title dynamic-sizing\">Ukjent brev</span><span class=\"x__pt8tzk-0 hAncxD title dynamic-sizing\">avslørt</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=\"Viser fram kjæresten\" href=\"https://www.dagbladet.no/kjendis/viser-fram-kjaeresten/81324866\"><figure class=\"x__sc-1an7vu1-0 hpZPQm\"><picture><img data-defer=\"view\" title=\"Image: Viser fram kjæresten\" alt=\"Image: Viser fram kjæresten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324880&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=276&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Viser fram</span><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">kjæresten</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=\"Militære styrker inntar Moskva\" href=\"https://www.dagbladet.no/nyheter/militaere-styrker-inntar-moskva/81322961\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Militære styrker inntar Moskva\" alt=\"Image: Militære styrker inntar Moskva\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81322970&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&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 ftetSQ title dynamic-sizing\">Militære styrker</span><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">inntar Moskva</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Stedatter nekter meg uskiftet bo\" href=\"https://www.dagbladet.no/tema/stedatter-nekter-meg-uskiftet-bo/80925022\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Stedatter nekter meg uskiftet bo\" alt=\"Image: - Stedatter nekter meg uskiftet bo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81268037&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=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">- Stedatter</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">nekter meg</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">uskiftet bo</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Passasjeren raser - så skjer dette\" href=\"https://www.dagbladet.no/video/passasjeren-angriper-bussjaforen-i-fart-/zUo6vxxg\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Passasjeren raser - så skjer dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81321798.jpg?imageId=81321798&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/26/b4771b8f-de2e-4774-8c85-f00adceb7585/gif_buss_-_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/26/b4771b8f-de2e-4774-8c85-f00adceb7585/gif_buss_-_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\">Passasjeren raser</span><span class=\"x__pt8tzk-0 kxzaKl title dynamic-sizing\">- så skjer dette</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ond, gammel og homo\" href=\"https://www.dagbladet.no/kjendis/ond-gammel-og-homo/81321834\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Ond, gammel og homo\" alt=\"Image: - Ond, gammel og homo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81321958&amp;panox=0&amp;panow=99.932614150943&amp;panoh=50.94905034965&amp;panoy=11.888111888112&amp;heightw=38.758287763713&amp;heighty=0&amp;heightx=30.775464135021&amp;heighth=93.03571375&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 iLHueX title dynamic-sizing\">- Ond, gammel</span><span class=\"x__pt8tzk-0 fDxrvm title dynamic-sizing\">og homo</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gjorde sjeldent funn: - Ganske magisk\" href=\"https://www.dagbladet.no/nyheter/gjorde-sjeldent-funn-ganske-magisk/81323243\"><figure class=\"x__sc-1an7vu1-0 kPAogU\"><picture><img data-defer=\"view\" title=\"Image: Gjorde sjeldent funn: - Ganske magisk\" alt=\"Image: Gjorde sjeldent funn: - Ganske magisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81323389&amp;panoy=27.98353909465&amp;panox=0&amp;panow=99.842766981132&amp;panoh=29.903977777778&amp;heightx=10.769230769231&amp;heightw=70.51282&amp;heighth=99.77628590604&amp;heighty=0&amp;width=485&amp;height=315&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">Gjorde sjeldent</span><span class=\"x__pt8tzk-0 erpCho title dynamic-sizing\">funn: - Ganske magisk</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=\"- Totalt knust\" href=\"https://www.dagbladet.no/kjendis/totalt-knust/81321684\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Totalt knust\" alt=\"Image: - Totalt knust\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81321711&amp;panoy=8.2661290322581&amp;panox=0&amp;panow=100&amp;panoh=37.567204301075&amp;heightx=0&amp;heightw=100&amp;heighth=37.567204301075&amp;heighty=8.2661290322581&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 dWzMnA title dynamic-sizing\">- Totalt knust</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=\"Overrasker: Ni år siden sist\" href=\"https://www.dagbladet.no/kjendis/overrasker-ni-ar-siden-sist/81307245\"><figure class=\"x__sc-1an7vu1-0 hIDOUr\"><picture><img data-defer=\"view\" title=\"Image: Overrasker: Ni år siden sist\" alt=\"Image: Overrasker: Ni år siden sist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81323350&amp;panox=0&amp;panow=99.842766981132&amp;panoh=49.771689041096&amp;panoy=9.5890410958904&amp;heighty=0.22371409395974&amp;heightx=46.046511627907&amp;heightw=42.635658604651&amp;heighth=99.77628590604&amp;width=402&amp;height=241&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Overrasker: Ni</span><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">år siden sist</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=\"Knausgård: Ny kone og nytt liv\" href=\"https://www.dagbladet.no/tema/knausgard-ny-kone-og-nytt-liv/81310229\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Knausgård: Ny kone og nytt liv\" alt=\"Image: Knausgård: Ny kone og nytt liv\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81276078&amp;panoy=7.2784810126582&amp;panox=0.22819052132701&amp;panow=99.771809478673&amp;panoh=22.632442405063&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 jdgMzU title dynamic-sizing\">Knausgård: Ny</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">kone og nytt liv</span></h3></header></a></article><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=\"Reagerer sterkt\" href=\"https://www.dagbladet.no/video/biter-fra-seg/xRG89emx\"><figure class=\"x__sc-1an7vu1-0 gIetcv moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Reagerer sterkt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81318004.jpg?imageId=81318004&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=197\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/25/01512cb7-b6f1-4b1d-a88f-2698d5d2ec77/gif_3.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/25/01512cb7-b6f1-4b1d-a88f-2698d5d2ec77/gif_3.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 cnaKkM title dynamic-sizing\">Reagerer sterkt</span></h3></header></a></article><div id=\"apos-medium-rectangle-perz3\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle-perz3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle-perz3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russiske soldater: - Tatt for mord\" href=\"https://www.dagbladet.no/nyheter/russiske-soldater-tatt-for-mord/81323614\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Russiske soldater: - Tatt for mord\" alt=\"Image: Russiske soldater: - Tatt for mord\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81323618&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 dyaAfc title dynamic-sizing\">Russiske soldater:</span><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">- Tatt for mord</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=\"- Kinesiske fly har krysset median-linja\" href=\"https://www.dagbladet.no/nyheter/kinesiske-fly-har-krysset-median-linja/81322879\"><figure class=\"x__sc-1an7vu1-0 krHhho\"><picture><img data-defer=\"view\" title=\"Image: - Kinesiske fly har krysset median-linja\" alt=\"Image: - Kinesiske fly har krysset median-linja\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81322883&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighth=97.350993377483&amp;heightw=39.473684210526&amp;heighty=0&amp;heightx=36.842105263158&amp;width=485&amp;height=262&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\">- Kinesiske fly har</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">krysset median-linja</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=\"Nå kommer sommeren: - Stor endring\" href=\"https://www.dagbladet.no/nyheter/na-kommer-sommeren-stor-endring/81324154\"><figure class=\"x__sc-1an7vu1-0 gaapxn\"><picture><img data-defer=\"view\" title=\"Image: Nå kommer sommeren: - Stor endring\" alt=\"Image: Nå kommer sommeren: - Stor endring\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324280&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=302&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">Nå kommer sommeren:</span><span class=\"x__pt8tzk-0 emaxbb title dynamic-sizing\">- Stor endring</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=\"Avslører kjærestens identitet\" href=\"https://www.dagbladet.no/kjendis/avslorer-kjaerestens-identitet/81312313\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Avslører kjærestens identitet\" alt=\"Image: Avslører kjærestens identitet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81310314&amp;panoy=3.9855072463768&amp;panox=0.23148148148148&amp;panow=100.23148148148&amp;panoh=26.630434782609&amp;heightx=0&amp;heightw=77.731092436975&amp;heighth=100.33112582781&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 gPIxea title dynamic-sizing\">Avslører kjærestens</span><span class=\"x__pt8tzk-0 ggbHpa title dynamic-sizing\">identitet</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russland: Flere skadd\" href=\"https://www.dagbladet.no/video/russland-flere-skadd/KBCP3BpB\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russland: Flere skadd\" alt=\"Image: Russland: Flere skadd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/KBCP3BpB-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 LzBnW title dynamic-sizing\">Russland:</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Flere skadd</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Batteridrevne motorsager: Vinnerne latterlig billig!\" href=\"https://www.dagbladet.no/tema/batteridrevne-motorsager-vinnerne-latterlig-billige/81086199\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Batteridrevne motorsager: Vinnerne latterlig billig!\" alt=\"Image: Batteridrevne motorsager: Vinnerne latterlig billig!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81125217&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=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 jRIgeY title dynamic-sizing\">Batteridrevne motorsager:</span><span class=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Vinnerne latterlig billig!</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=\"Dramatisk ulykke: - Masse blod\" href=\"https://www.dagbladet.no/kjendis/dramatisk-ulykke-masse-blod/81312178\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dramatisk ulykke: - Masse blod\" alt=\"Image: Dramatisk ulykke: - Masse blod\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81308790&amp;panox=0.23148148148148&amp;panow=100.23148148148&amp;panoh=60.245901639344&amp;panoy=16.393442622951&amp;heighty=0.33112582781457&amp;heightx=34.944237918216&amp;heightw=34.386617100372&amp;heighth=100.33112582781&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\">Dramatisk ulykke:</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">- Masse blod</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=\"Nye påstander: Putin sto ikke bak\" href=\"https://www.dagbladet.no/nyheter/nye-pastander-putin-sto-ikke-bak/81324408\"><figure class=\"x__sc-1an7vu1-0 dmGuJR\"><picture><img data-defer=\"view\" title=\"Image: Nye påstander: Putin sto ikke bak\" alt=\"Image: Nye påstander: Putin sto ikke bak\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81308299&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=340&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\">Nye påstander:</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Putin sto ikke bak</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=\"Slaktes:- Ekstremist\" href=\"https://www.dagbladet.no/nyheter/slaktes-ekstremist/81324635\"><figure class=\"x__sc-1an7vu1-0 ioubUL\"><picture><img data-defer=\"view\" title=\"Image: Slaktes:- Ekstremist\" alt=\"Image: Slaktes:- Ekstremist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81298678&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=324&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 kauVAS title dynamic-sizing\">Slaktes:-</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">Ekstremist</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=\"Glimt-bildene forbløffer\" href=\"https://www.dagbladet.no/sport/glimt-bildene-forbloffer/81324051\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Glimt-bildene forbløffer\" alt=\"Image: Glimt-bildene forbløffer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324282&amp;panoy=2.8571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=14.734299516908&amp;heightw=14.469453376206&amp;heightx=66.881028938907&amp;heighth=35.507246376812&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 dWzMnA title dynamic-sizing\">Glimt-bildene</span><span class=\"x__pt8tzk-0 kkHfrE title dynamic-sizing\">forbløffer</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=\"Kuttet dette - kiloene forsvant\" href=\"https://www.dagbladet.no/tema/kuttet-dette-kiloene-forsvant/81245151\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Kuttet dette - kiloene forsvant\" alt=\"Image: Kuttet dette - kiloene forsvant\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81262128&amp;panoy=14.815578231293&amp;panox=28.724497991968&amp;panow=42.168674698795&amp;panoh=48.299319727891&amp;heighty=4.7872340425532&amp;heightw=14.297053620955&amp;heighth=78.946532984293&amp;heightx=52.262090483619&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Kuttet dette -</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">kiloene forsvant</span></h3></header></a></article><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=\"Filmer uidentifisert objekt\" href=\"https://www.dagbladet.no/video/forbloffet-hva-kan-det-vaere-/xJ8ElUdF\"><figure class=\"x__sc-1an7vu1-0 dystQj moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Filmer uidentifisert objekt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81321984.jpg?imageId=81321984&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=217\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/26/0eac344d-389b-4f53-8ac7-211e28aed9b6/ufo_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/26/0eac344d-389b-4f53-8ac7-211e28aed9b6/ufo_gif.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 bUEFlv title dynamic-sizing\">Filmer uidentifisert objekt</span></h3></header></a></article><div id=\"apos-medium-rectangle-perz4\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle-perz4\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle-perz4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Etterlot seg tonn med gjeld\" href=\"https://www.dagbladet.no/kjendis/etterlot-seg-tonn-med-gjeld/81314615\"><figure class=\"x__sc-1an7vu1-0 iFCyIa\"><picture><img data-defer=\"view\" title=\"Image: Etterlot seg tonn med gjeld\" alt=\"Image: Etterlot seg tonn med gjeld\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81316113&amp;panoy=20.344827586207&amp;panox=0&amp;panow=100&amp;panoh=24.48275862069&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=227&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 bkgkdp title dynamic-sizing\">Etterlot seg</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">tonn med gjeld</span></h3></header></a></article><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=\"Sterke reaksjoner\" href=\"https://www.dagbladet.no/sport/sterke-reaksjoner/81324990\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Sterke reaksjoner\" alt=\"Image: Sterke reaksjoner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324993&amp;panoh=47.333333333333&amp;panoy=4&amp;panox=0&amp;panow=100&amp;heighth=100&amp;heighty=0&amp;heightx=3.8834951456311&amp;heightw=43.68932038835&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">Sterke reaksjoner</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=\"Alderen sjokkerer\" href=\"https://www.dagbladet.no/nyheter/alderen-sjokkerer/81320860\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Alderen sjokkerer\" alt=\"Image: Alderen sjokkerer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81321063&amp;panoy=19.773095623987&amp;panow=100&amp;panoh=45.299837925446&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=45.299837925446&amp;heighty=19.773095623987&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 bSlVPf title dynamic-sizing\">Alderen</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">sjokkerer</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=\"Avviser rykter\" href=\"https://www.dagbladet.no/sport/avviser-rykter/81320128\"><figure class=\"x__sc-1an7vu1-0 cRGFeD\"><picture><img data-defer=\"view\" title=\"Image: Avviser rykter\" alt=\"Image: Avviser rykter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81320140&amp;panoy=22.142857142857&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighth=100&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=511&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 bWSnVS title dynamic-sizing\">Avviser rykter</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=\"- Skam dere\" href=\"https://www.dagbladet.no/nyheter/skam-dere/81324654\"><figure class=\"x__sc-1an7vu1-0 eMbtnT\"><picture><img data-defer=\"view\" title=\"Image: - Skam dere\" alt=\"Image: - Skam dere\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324658&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=256&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\">- Skam dere</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=\"- Desperat\" href=\"https://www.dagbladet.no/kjendis/desperat/81324073\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Desperat\" alt=\"Image: - Desperat\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324115&amp;panow=100&amp;panoh=39.444444444444&amp;panoy=10.555555555556&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 kyzRFP title dynamic-sizing\">- Desperat</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dødsårsaken bekreftet\" href=\"https://www.dagbladet.no/kjendis/dodsarsaken-bekreftet/81322376\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Dødsårsaken bekreftet\" alt=\"Image: Dødsårsaken bekreftet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81322384&amp;panoy=0&amp;panow=100&amp;panoh=84.441087613293&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=84.441087613293&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 iCwWtY title dynamic-sizing\">Dødsårsaken</span><span class=\"x__pt8tzk-0 iCqzVN title dynamic-sizing\">bekreftet</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=\"- Forelsket på ny\" href=\"https://www.dagbladet.no/kjendis/forelsket-pa-ny/81310845\"><figure class=\"x__sc-1an7vu1-0 kDkkya\"><picture><img data-defer=\"view\" title=\"Image: - Forelsket på ny\" alt=\"Image: - Forelsket på ny\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81298954&amp;panoy=16.438356164384&amp;panox=0&amp;panow=99.848484545455&amp;panoh=51.141552054795&amp;heightx=27.155172413793&amp;heightw=41.235631896552&amp;heighth=99.784945806452&amp;heighty=0&amp;width=567&amp;height=292&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\">- Forelsket på ny</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=\"Navalnyj: Nye opplysninger ryster\" href=\"https://www.dagbladet.no/video/navalnyj-nye-opplysninger-ryster/JHLyQU30\"><figure class=\"x__sc-1an7vu1-0 idKCHs\"><picture><img data-defer=\"view\" title=\"Image: Navalnyj: Nye opplysninger ryster\" alt=\"Image: Navalnyj: Nye opplysninger ryster\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/JHLyQU30-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Navalnyj: Nye</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">opplysninger ryster</span></h3></header></a></article><article class=\"preview columns small-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=\"Oppskriften: Kvitt magefettet raskt\" href=\"https://www.dagbladet.no/tema/excar-formelen-kvitt-magefettet-pa-sju-uker/81314406\"><figure class=\"x__sc-1an7vu1-0 aqCCR\"><picture><img data-defer=\"view\" title=\"Image: Oppskriften: Kvitt magefettet raskt\" alt=\"Image: Oppskriften: Kvitt magefettet raskt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81316268&amp;panoy=31.914893617021&amp;panox=0&amp;panoh=51.063829787234&amp;panow=100&amp;heighty=0&amp;heightx=23.076923076923&amp;heightw=40.723981900452&amp;heighth=100&amp;width=320&amp;height=168&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Oppskriften: Kvitt</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">magefettet raskt</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=\"- Hans største ønske var å drepe i krig\" href=\"https://www.dagbladet.no/nyheter/hans-storste-onske-var-a-drepe-i-krig/81319100\"><figure class=\"x__sc-1an7vu1-0 jJPOlH\"><picture><img data-defer=\"view\" title=\"Image: - Hans største ønske var å drepe i krig\" alt=\"Image: - Hans største ønske var å drepe i krig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81319315&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=56.451612903226&amp;heightx=0&amp;heightw=36.974789915966&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=341&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">- Hans største ønske</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">var å drepe i krig</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ikke til å kjenne igjen\" href=\"https://www.dagbladet.no/kjendis/ikke-til-a-kjenne-igjen/81318584\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ikke til å kjenne igjen\" alt=\"Image: Ikke til å kjenne igjen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81318629&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hOOMjn title dynamic-sizing\">Ikke til å</span><span class=\"x__pt8tzk-0 gALHSm title dynamic-sizing\">kjenne igjen</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=\"Mystiske «edderkopper» på Mars\" href=\"https://www.dagbladet.no/nyheter/mystiske-edderkopper-pa-mars/81318097\"><figure class=\"x__sc-1an7vu1-0 jjcUMQ\"><picture><img data-defer=\"view\" title=\"Image: Mystiske «edderkopper» på Mars\" alt=\"Image: Mystiske «edderkopper» på Mars\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81318117&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=485&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jCkLvS title dynamic-sizing\">Mystiske</span><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">«edderkopper» på Mars</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=\"- Putin har det travelt\" href=\"https://www.dagbladet.no/nyheter/putin-har-det-travelt/81309569\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Putin har det travelt\" alt=\"Image: - Putin har det travelt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81235963&amp;panoh=51.141552054795&amp;panoy=19.86301369863&amp;panox=0&amp;panow=99.848484545455&amp;heightx=29.122807017544&amp;heighty=15.706806282723&amp;heightw=33.56725122807&amp;heighth=80.977312041885&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\">- Putin har</span><span class=\"x__pt8tzk-0 dJenrE title dynamic-sizing\">det travelt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard6\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Utro på venninnetur: Her skjer det\" href=\"https://www.dagbladet.no/tema/utro-pa-venninneturher-skjer-det/81149734\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Utro på venninnetur: Her skjer det\" alt=\"Image: Utro på venninnetur: Her skjer det\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81171525&amp;panoy=0&amp;panox=0.16025673076923&amp;panow=100.16025673077&amp;panoh=51.318945323741&amp;heighty=0.22831095890411&amp;heightw=40.606060909091&amp;heighth=100.2283109589&amp;heightx=27.727272727273&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 iNHyie title dynamic-sizing\">Utro på venninnetur:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Her skjer det</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-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 før fødsel: - Har ikke ord\" href=\"https://www.dagbladet.no/kjendis/dode-for-fodsel-har-ikke-ord/81324456\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Døde før fødsel: - Har ikke ord\" alt=\"Image: Døde før fødsel: - Har ikke ord\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324486&amp;panoy=15.551974214343&amp;panox=0&amp;panow=100&amp;panoh=45.044319097502&amp;heightx=0&amp;heightw=100&amp;heighth=45.044319097502&amp;heighty=15.551974214343&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\">Døde før fødsel:</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">- Har ikke ord</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=\"Dyster spådom\" href=\"https://www.dagbladet.no/sport/dyster-spadom/81318653\"><figure class=\"x__sc-1an7vu1-0 btjLaZ\"><picture><img data-defer=\"view\" title=\"Image: Dyster spådom\" alt=\"Image: Dyster spådom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81320077&amp;panoy=21.608040201005&amp;panox=13.377926421405&amp;panow=70.234113712375&amp;panoh=35.678391959799&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=25.339366515837&amp;heighty=0&amp;width=402&amp;height=391&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">Dyster spådom</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ingen stoppet: - Helt forferdelig\" href=\"https://www.dagbladet.no/nyheter/ingen-stoppet-helt-forferdelig/81317603\"><figure class=\"x__sc-1an7vu1-0 iMoPFf\"><picture><img data-defer=\"view\" title=\"Image: Ingen stoppet: - Helt forferdelig\" alt=\"Image: Ingen stoppet: - Helt forferdelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81317623&amp;panox=0&amp;panow=100&amp;panoh=25.448028673835&amp;panoy=48.387096774194&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=402&amp;height=319&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 cKlSIC title dynamic-sizing\">Ingen stoppet:</span><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">- Helt forferdelig</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=\"Avslører detaljer om sexscenene\" href=\"https://www.dagbladet.no/kjendis/avslorer-detaljer-om-sexscenene/81323687\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Avslører detaljer om sexscenene\" alt=\"Image: Avslører detaljer om sexscenene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81323768&amp;panow=100&amp;panoh=51.079136690647&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=31.2&amp;heightw=36&amp;heighth=88.55421686747&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 dBWQRi title dynamic-sizing\">Avslører detaljer</span><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">om sexscenene</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=\"Nytt middel mot ereksjonssvikt hylles\" href=\"https://www.dagbladet.no/tema/nytt-middel-mot-ereksjonssvikt-hylles/81161606\"><figure class=\"x__sc-1an7vu1-0 iRrFGC\"><picture><img data-defer=\"view\" title=\"Image: Nytt middel mot ereksjonssvikt hylles\" alt=\"Image: Nytt middel mot ereksjonssvikt hylles\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81161841&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panoy=27.659574468085&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&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\">Nytt middel mot</span><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">ereksjonssvikt hylles</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"De er sønnene\" href=\"https://www.dagbladet.no/video/de-er-sonnene/0WIF6AwQ\"><figure class=\"x__sc-1an7vu1-0 lcWYHB\"><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><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=\"- Hvordan er det mulig?\" href=\"https://www.dagbladet.no/sport/kan-bli-arets-spiller/81318661\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Hvordan er det mulig?\" alt=\"Image: - Hvordan er det mulig?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81318955&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=23.571428571429&amp;panox=0&amp;heighty=0&amp;heightx=23.981900452489&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 gRLJwN title dynamic-sizing\">- Hvordan er</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">det mulig?</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=\"Kasai i sorg\" href=\"https://www.dagbladet.no/sport/kasai-i-sorg/81322216\"><figure class=\"x__sc-1an7vu1-0 gQoIpx\"><picture><img data-defer=\"view\" title=\"Image: Kasai i sorg\" alt=\"Image: Kasai i sorg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80859883&amp;panoy=15.714285714286&amp;panow=100&amp;panoh=50.714285714286&amp;panox=0&amp;heighty=0&amp;heightx=17.647058823529&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=336&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">Kasai i sorg</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=\"Superduell: - Brutalt\" href=\"https://www.dagbladet.no/sport/superduell-brutalt/81323626\"><figure class=\"x__sc-1an7vu1-0 hygKBp\"><picture><img data-defer=\"view\" title=\"Image: Superduell: - Brutalt\" alt=\"Image: Superduell: - Brutalt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81323645&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=255&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\">Superduell:</span><span class=\"x__pt8tzk-0 gNDiBf title dynamic-sizing\">- Brutalt</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Dummeste jeg har vært med på\" href=\"https://www.dagbladet.no/kjendis/dummeste-jeg-har-vaert-med-pa/81309170\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Dummeste jeg har vært med på\" alt=\"Image: - Dummeste jeg har vært med på\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81309197&amp;panoy=16.02787456446&amp;panox=0&amp;panow=100&amp;panoh=25.783972125436&amp;heightx=17.241379310345&amp;heightw=81.034482758621&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 hrVcDN title dynamic-sizing\">- Dummeste jeg</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">har vært med på</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard7\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12 bg-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=\"Skrekkangrep i dyrehagen\" href=\"https://www.dagbladet.no/video/skrekkangrep-i-dyrehagen/3MmcEKvl\"><figure class=\"x__sc-1an7vu1-0 ejnyBo moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Skrekkangrep i dyrehagen\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81322195.jpg?imageId=81322195&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=164\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/26/67583895-fd0e-4228-89cc-40028ceddf3a/gif_panda_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/26/67583895-fd0e-4228-89cc-40028ceddf3a/gif_panda_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 ijicdz title dynamic-sizing\">Skrekkangrep</span><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">i dyrehagen</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=\"Ukjent pensjonsbombe: Reglene «alle» misforstår\" href=\"https://www.dagbladet.no/tema/ukjent-pensjonsbombe-reglene-alle-misforstar/81112834\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Ukjent pensjonsbombe: Reglene «alle» misforstår\" alt=\"Image: Ukjent pensjonsbombe: Reglene «alle» misforstår\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81118714&amp;panox=0&amp;panow=99.893674641148&amp;panoh=50.91926618705&amp;panoy=25.179856115108&amp;heightw=40.994420091324&amp;heighty=0&amp;heightx=24.200913242009&amp;heighth=99.847794520548&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 beDNpZ title dynamic-sizing\">Ukjent pensjonsbombe:</span><span class=\"x__pt8tzk-0 hpQSgl title dynamic-sizing\">Reglene «alle» misforstår</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=\"Bomben: Advarer\" href=\"https://www.dagbladet.no/sport/bomben-advarer/81320960\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Bomben: Advarer\" alt=\"Image: Bomben: Advarer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81321587&amp;panoy=13.375796178344&amp;panox=6.7796610169492&amp;panow=88.983050847458&amp;panoh=45.222929936306&amp;heightw=33.088235294118&amp;heighth=81.21546961326&amp;heighty=0&amp;heightx=36.029411764706&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 bWzzkU title dynamic-sizing\">Bomben:</span><span class=\"x__pt8tzk-0 kVcwCb title dynamic-sizing\">Advarer</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=\"- Totalt sjokk\" href=\"https://www.dagbladet.no/sport/totalt-sjokk/81320323\"><figure class=\"x__sc-1an7vu1-0 faiitY\"><picture><img data-defer=\"view\" title=\"Image: - Totalt sjokk\" alt=\"Image: - Totalt sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81320354&amp;panoy=21.538461538462&amp;panox=0&amp;panow=53.846153846154&amp;panoh=27.307692307692&amp;heighty=20.531400966184&amp;heightw=14.469453376206&amp;heighth=35.507246376812&amp;heightx=17.041800643087&amp;width=485&amp;height=418&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\">- Totalt sjokk</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=\"Seks grep fjerner hudormene\" href=\"https://www.dagbladet.no/tema/seks-grep-fjerner-hudormene/81268048\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Seks grep fjerner hudormene\" alt=\"Image: Seks grep fjerner hudormene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81268802&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=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 LzBnW title dynamic-sizing\">Seks grep</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">fjerner hudormene</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=\"Norsk 15-åring sjokkerer i England\" href=\"https://www.dagbladet.no/video/norsk-15-aring-gar-viralt-i-england/uarEcigj\"><figure class=\"x__sc-1an7vu1-0 gmpxUf moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Norsk 15-åring sjokkerer i England\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81324889.jpg?imageId=81324889&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=178\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/03/21/5d39f976-577b-42cf-9c16-69d94c6b97ec/gif_thelo_rabona.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/03/21/5d39f976-577b-42cf-9c16-69d94c6b97ec/gif_thelo_rabona.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 frzFun title dynamic-sizing\">Norsk 15-åring</span><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">sjokkerer i England</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=\"Mottar drapstrusler etter Netflix-suksess\" href=\"https://www.dagbladet.no/kjendis/mottar-drapstrusler-etter-netflix-suksess/81324173\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Mottar drapstrusler etter Netflix-suksess\" alt=\"Image: Mottar drapstrusler etter Netflix-suksess\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81324366&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=6.4285714285714&amp;heightx=0&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Mottar drapstrusler</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">etter Netflix-suksess</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=\"Har kreft:- Skremmende\" href=\"https://www.dagbladet.no/kjendis/har-kreft-skremmende/81323030\"><figure class=\"x__sc-1an7vu1-0 ixaLcU\"><picture><img data-defer=\"view\" title=\"Image: Har kreft:- Skremmende\" alt=\"Image: Har kreft:- Skremmende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81323017&amp;panoy=10.63829787234&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panox=0.15723301886793&amp;heighty=0.22371409395974&amp;heightx=32.735426008969&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;width=402&amp;height=257&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Har kreft:-</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">Skremmende</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard8\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Stor endring i krigen\" href=\"https://www.dagbladet.no/video/-stor-endring-i-krigen/qCLhw26G\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Stor endring i krigen\" alt=\"Image: - Stor endring i krigen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/qCLhw26G-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\">- Stor endring</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">i krigen</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=\"«Amanda» var utro: Unnskyldningene hun serverte \" href=\"https://www.dagbladet.no/tema/amanda-var-utro-unnskyldningene-hun-serverte/81149452\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: «Amanda» var utro: Unnskyldningene hun serverte \" alt=\"Image: «Amanda» var utro: Unnskyldningene hun serverte \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81160005&amp;panoy=13.138686131387&amp;panox=0&amp;panow=99.759615384615&amp;panoh=51.459854014599&amp;heighty=0.3448275862069&amp;heightw=40.227272727273&amp;heighth=100.34482758621&amp;heightx=15.909090909091&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">«Amanda» var utro:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Unnskyldningene</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">hun serverte </span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Arvefella: Lillesøster fikk overført familiehytta\" href=\"https://www.dagbladet.no/tema/arvefella-lillesoster-fikk-overfort-familiehytta/80963625\"><figure class=\"x__sc-1an7vu1-0 jDKzJI\"><picture><img data-defer=\"view\" title=\"Image: Arvefella: Lillesøster fikk overført familiehytta\" alt=\"Image: Arvefella: Lillesøster fikk overført familiehytta\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80963630&amp;panoy=26.950354609929&amp;panox=0&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heighty=0.22371409395974&amp;heightx=27.80269058296&amp;width=320&amp;height=238&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 iNHyie title dynamic-sizing\">Arvefella: Lillesøster</span><span class=\"x__pt8tzk-0 fjKRAi title dynamic-sizing\">fikk overført familiehytta</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Reagerer: - Voldsom\" href=\"https://www.dagbladet.no/video/reagerer-voldsom/v2blPJ8V\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Voldsom\" alt=\"Image: Reagerer: - Voldsom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/v2blPJ8V-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ioa-DgC title dynamic-sizing\">Reagerer:</span><span class=\"x__pt8tzk-0 cCIJgC title dynamic-sizing\">- Voldsom</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=\"- Driter i ei tønne\" href=\"https://www.dagbladet.no/kjendis/driter-i-ei-tonne/81303871\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Driter i ei tønne\" alt=\"Image: - Driter i ei tønne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81307485&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=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 iWZcdV title dynamic-sizing\">- Driter</span><span class=\"x__pt8tzk-0 kAKGGI title dynamic-sizing\">i ei tønne</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=\"Dukket opp i Oslofjorden\" href=\"https://www.dagbladet.no/nyheter/dukket-opp-i-oslofjorden/81322558\"><figure class=\"x__sc-1an7vu1-0 fYvkjy\"><picture><img data-defer=\"view\" title=\"Image: Dukket opp i Oslofjorden\" alt=\"Image: Dukket opp i Oslofjorden\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81322611&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=328&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">Dukket opp i</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">Oslofjorden</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 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=\"Løfter henne opp\" href=\"https://www.dagbladet.no/video/prover-a-holde-seg-fast/DX6zj6vh\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Løfter henne opp\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81322795.jpg?imageId=81322795&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/26/3c02a0c8-a772-49c0-b304-6495a9271f27/gif1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/26/3c02a0c8-a772-49c0-b304-6495a9271f27/gif1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Løfter henne opp</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=\"Utroskap: Hvorfor skjer det med meg?\" href=\"https://www.dagbladet.no/tema/utroskap-hvorforskjer-det-med-meg/81206139\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Utroskap: Hvorfor skjer det med meg?\" alt=\"Image: Utroskap: Hvorfor skjer det med meg?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81248084&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=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\">Utroskap: Hvorfor</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">skjer det med meg?</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=\"Svarer etter spøk om gruppevoldtekt\" href=\"https://www.dagbladet.no/kjendis/svarer-etter-spok-om-gruppevoldtekt/81320707\"><figure class=\"x__sc-1an7vu1-0 dPlQCr\"><picture><img data-defer=\"view\" title=\"Image: Svarer etter spøk om gruppevoldtekt\" alt=\"Image: Svarer etter spøk om gruppevoldtekt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81320284&amp;panoy=0&amp;panox=0&amp;panow=100.23148148148&amp;panoh=60.743801652893&amp;heightx=31.970260223048&amp;heightw=34.386617100372&amp;heighth=100.33112582781&amp;heighty=0.33112582781457&amp;width=402&amp;height=265&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Svarer etter spøk</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">om gruppevoldtekt</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=\"Aldri skjedd før\" href=\"https://www.dagbladet.no/nyheter/aldri-skjedd-for/81318805\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Aldri skjedd før\" alt=\"Image: Aldri skjedd før\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81319638&amp;panoy=10.349288486417&amp;panox=0&amp;panow=100&amp;panoh=72.315653298836&amp;heighty=10.349288486417&amp;heightx=0&amp;heightw=100&amp;heighth=72.315653298836&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 hPDIHE title dynamic-sizing\">Aldri skjedd før</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=\"Lindas (36) oppskrift: Kiloene renner av!\" href=\"https://www.dagbladet.no/tema/lindas-36-oppskriftkiloene-renner-av/81308092\"><figure class=\"x__sc-1an7vu1-0 fpAqZR\"><picture><img data-defer=\"view\" title=\"Image: Lindas (36) oppskrift: Kiloene renner av!\" alt=\"Image: Lindas (36) oppskrift: Kiloene renner av!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81319259&amp;panoy=0&amp;panox=32.863620071685&amp;panow=39.068100358423&amp;panoh=75.510204081633&amp;heightx=52.401746724891&amp;heightw=7.5109170305677&amp;heighth=70.5&amp;heighty=0&amp;width=320&amp;height=319&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Lindas (36) oppskrift:</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Kiloene renner av!</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russisk gassrørledning ødelagt\" href=\"https://www.dagbladet.no/video/russisk-gassrorledning-odelagt/oVX5OQgJ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russisk gassrørledning ødelagt\" alt=\"Image: Russisk gassrørledning ødelagt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/oVX5OQgJ-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 iyrywY title dynamic-sizing\">Russisk</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">gassrørledning</span><span class=\"x__pt8tzk-0 bFQuDG title dynamic-sizing\">ødelagt</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=\"Avslører etter sjokket: Nektet\" href=\"https://www.dagbladet.no/sport/avslorer-etter-sjokket-nektet/81317695\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Avslører etter sjokket: Nektet\" alt=\"Image: Avslører etter sjokket: Nektet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81317719&amp;panow=100&amp;panoh=22.539682539683&amp;panoy=27.619047619048&amp;panox=0&amp;heighty=0&amp;heightx=7.1428571428571&amp;heightw=91.836734693878&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 bxtuZJ title dynamic-sizing\">Avslører etter</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">sjokket: Nektet</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=\"Funnet død\" href=\"https://www.dagbladet.no/sport/funnet-dod/81322831\"><figure class=\"x__sc-1an7vu1-0 bLPPUH\"><picture><img data-defer=\"view\" title=\"Image: Funnet død\" alt=\"Image: Funnet død\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81322867&amp;panow=100&amp;panoh=43.030303030303&amp;panox=0&amp;panoy=0&amp;heighty=0&amp;heightx=25.668449197861&amp;heightw=48.128342245989&amp;heighth=100&amp;width=402&amp;height=375&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\">Funnet død</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 bg-yellow breaking--pulse-kicker\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kadyrov er alvorlig syk\" href=\"https://www.dagbladet.no/video/kadyrov-slar-tilbake-mot-helseryktene/p49eRJQN\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: - Kadyrov er alvorlig syk\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81310357.jpg?imageId=81310357&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/24/85da5639-a1f2-40b4-87a0-5eb78bd4a0f0/gif_-_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/24/85da5639-a1f2-40b4-87a0-5eb78bd4a0f0/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 jfhrCI title dynamic-sizing\">- Kadyrov er</span><span class=\"x__pt8tzk-0 lfBuL title dynamic-sizing\">alvorlig syk</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nye pensjonsregler: Jobb mindre - få mer \" href=\"https://www.dagbladet.no/tema/nye-pensjonsregler-jobb-mindre-fa-mer/81083251\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Nye pensjonsregler: Jobb mindre - få mer \" alt=\"Image: Nye pensjonsregler: Jobb mindre - få mer \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81107882&amp;panoy=17.985611510791&amp;panox=0&amp;panow=99.893674641148&amp;panoh=50.91926618705&amp;heightx=15.981735159817&amp;heighty=0&amp;heightw=40.994420091324&amp;heighth=99.847794520548&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\">Nye pensjonsregler:</span><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Jobb mindre - få mer </span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Førerkort-formelen: Fire spørsmål avgjør\" href=\"https://www.dagbladet.no/tema/forerkort-formelen-fire-sporsmal-avgjor/81263042\"><figure class=\"x__sc-1an7vu1-0 jyPXHD\"><picture><img data-defer=\"view\" title=\"Image: Førerkort-formelen: Fire spørsmål avgjør\" alt=\"Image: Førerkort-formelen: Fire spørsmål avgjør\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81270290&amp;panoy=38.386830985915&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.173708450704&amp;heightx=40.990990990991&amp;heightw=41.291290990991&amp;heighth=99.77628590604&amp;heighty=0&amp;width=320&amp;height=243&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\">Førerkort-formelen:</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Fire spørsmål avgjør</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Går galt på direkten\" href=\"https://www.dagbladet.no/video/gar-galt-pa-direkten/kGsNHSOb\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Går galt på direkten\" alt=\"Image: Går galt på direkten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kGsNHSOb-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 iyrywY title dynamic-sizing\">Går galt</span><span class=\"x__pt8tzk-0 ivnriz title dynamic-sizing\">på direkten</span></h3></header></a></article><div id=\"apos-medium-rectangle9\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard11\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12 bg-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=\"Hulsker blir tatt på fersken\" href=\"https://www.dagbladet.no/video/tv-profil-tas-pa-fersken/bDDEVKRQ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Hulsker blir tatt på fersken\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81250434.jpg?imageId=81250434&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/27/06d80fe0-57fb-4b11-ad8d-0ddcdc06ba2f/gif_bernt_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/27/06d80fe0-57fb-4b11-ad8d-0ddcdc06ba2f/gif_bernt_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\">Hulsker blir</span><span class=\"x__pt8tzk-0 erpCho title dynamic-sizing\">tatt på fersken</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=\"IBS: Rask og gratis behandling\" href=\"https://www.dagbladet.no/tema/ibs-rask-og-gratis-behandling/81053082\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: IBS: Rask og gratis behandling\" alt=\"Image: IBS: Rask og gratis behandling\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81085233&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=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 bwGQrt title dynamic-sizing\">IBS: Rask og</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">gratis behandling</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nav-legene: Dette stopper uføresøknaden\" href=\"https://www.dagbladet.no/tema/ufore-legene-dette-avgjor-soknaden/81154911\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Nav-legene: Dette stopper uføresøknaden\" alt=\"Image: Nav-legene: Dette stopper uføresøknaden\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81148928&amp;panox=0.15723301886793&amp;panoy=21.985815602837&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heighty=0&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heightx=18.834080717489&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 dyaAfc title dynamic-sizing\">Nav-legene:</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Dette stopper</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">uføresøknaden</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Mener denne avslører Ukraina\" href=\"https://www.dagbladet.no/video/mener-denne-avslorer-ukraina/bztyc1yo\"><figure class=\"x__sc-1an7vu1-0 iPjCRj\"><picture><img data-defer=\"view\" title=\"Image: Mener denne avslører Ukraina\" alt=\"Image: Mener denne avslører Ukraina\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/bztyc1yo-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Mener denne</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">avslører Ukraina</span></h3></header></a></article><div id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Minus ti kilo før sommeren\" href=\"https://www.dagbladet.no/tema/ned-ti-kilo-for-sommeren/81111409\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Minus ti kilo før sommeren\" alt=\"Image: Minus ti kilo før sommeren\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81113834&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=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\">Minus ti kilo</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">før sommeren</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=\"Da blir solkremen dårlig\" href=\"https://www.dagbladet.no/video/merk-den-med-dato/OSRCHCB4\"><div class=\"kicker\"><div class=\"kicker-content\">☀️</div></div><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Da blir solkremen dårlig\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/78977117.jpg?imageId=78977117&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/04/04/b1267c39-69e1-4e54-ab3f-3359e57c74f9/gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/04/04/b1267c39-69e1-4e54-ab3f-3359e57c74f9/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 hIOHzH title dynamic-sizing\">Da blir</span><span class=\"x__pt8tzk-0 fopCi title dynamic-sizing\">solkremen dårlig</span></h3></header></a></article></div></div><div id=\"apos-netboard12\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard12&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ett grep: Turid-Helen (39) kvitt magefettet\" href=\"https://www.dagbladet.no/ett-grep-turid-helen-39-kvitt-magefettet/81209578\"><figure class=\"x__sc-1an7vu1-0 dAklYm\"><picture><img data-defer=\"view\" title=\"Image: Ett grep: Turid-Helen (39) kvitt magefettet\" alt=\"Image: Ett grep: Turid-Helen (39) kvitt magefettet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81209672&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=320&amp;height=201&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Ett grep: Turid-Helen</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">(39) kvitt magefettet</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Larvik: - Politiet var oppgitt\" href=\"https://www.dagbladet.no/video/larvik-politiet-var-oppgitt/WWtMk2hx\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Larvik: - Politiet var oppgitt\" alt=\"Image: Larvik: - Politiet var oppgitt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/WWtMk2hx-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 ihkPAv title dynamic-sizing\">Larvik: - Politiet</span><span class=\"x__pt8tzk-0 jIyTDK title dynamic-sizing\">var oppgitt</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>"]