["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .pRYLl.pRYLl.pRYLl.pRYLl{height:0;padding-bottom:51.75%;}/*!sc*/ .keevkX.keevkX.keevkX.keevkX{height:0;padding-bottom:50.72%;}/*!sc*/ .bzUfFP.bzUfFP.bzUfFP.bzUfFP{height:0;padding-bottom:75%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .blgNiS.blgNiS.blgNiS.blgNiS{height:0;padding-bottom:112.43%;}/*!sc*/ .ldHUSz.ldHUSz.ldHUSz.ldHUSz{height:0;padding-bottom:66.66%;}/*!sc*/ .jLYMaS.jLYMaS.jLYMaS.jLYMaS{height:0;padding-bottom:55.05%;}/*!sc*/ .htBhCB.htBhCB.htBhCB.htBhCB{height:0;padding-bottom:89.3%;}/*!sc*/ .hygKBp.hygKBp.hygKBp.hygKBp{height:0;padding-bottom:63.43%;}/*!sc*/ .dfJunC.dfJunC.dfJunC.dfJunC{height:0;padding-bottom:69.06%;}/*!sc*/ .juZrXb.juZrXb.juZrXb.juZrXb{height:0;padding-bottom:70.92%;}/*!sc*/ .fHbpUh.fHbpUh.fHbpUh.fHbpUh{height:0;padding-bottom:52.98%;}/*!sc*/ .ebIGPt.ebIGPt.ebIGPt.ebIGPt{height:0;padding-bottom:52.81%;}/*!sc*/ .hcsRHl.hcsRHl.hcsRHl.hcsRHl{height:0;padding-bottom:91.79%;}/*!sc*/ .hpZPQm.hpZPQm.hpZPQm.hpZPQm{height:0;padding-bottom:68.65%;}/*!sc*/ .iFvLxO.iFvLxO.iFvLxO.iFvLxO{height:0;padding-bottom:74.68%;}/*!sc*/ .YTIkI.YTIkI.YTIkI.YTIkI{height:0;padding-bottom:55.47%;}/*!sc*/ .ctaOyT.ctaOyT.ctaOyT.ctaOyT{height:0;padding-bottom:73.88%;}/*!sc*/ .exFxxY.exFxxY.exFxxY.exFxxY{height:0;padding-bottom:53.23%;}/*!sc*/ .fOLgRO.fOLgRO.fOLgRO.fOLgRO{height:0;padding-bottom:70.93%;}/*!sc*/ .irhPHF.irhPHF.irhPHF.irhPHF{height:0;padding-bottom:62.68%;}/*!sc*/ .ktenGW.ktenGW.ktenGW.ktenGW{height:0;padding-bottom:87.42%;}/*!sc*/ .eekAZq.eekAZq.eekAZq.eekAZq{height:0;padding-bottom:56.71%;}/*!sc*/ .evezpr.evezpr.evezpr.evezpr{height:0;padding-bottom:64.42%;}/*!sc*/ .gkSegO.gkSegO.gkSegO.gkSegO{height:0;padding-bottom:65.93%;}/*!sc*/ .iCPOVH.iCPOVH.iCPOVH.iCPOVH{height:0;padding-bottom:54.63%;}/*!sc*/ .hrRtCC.hrRtCC.hrRtCC.hrRtCC{height:0;padding-bottom:104.22%;}/*!sc*/ .gjAolr.gjAolr.gjAolr.gjAolr{height:0;padding-bottom:53.75%;}/*!sc*/ .dRaWNy.dRaWNy.dRaWNy.dRaWNy{height:0;padding-bottom:75.87%;}/*!sc*/ .gIetcv.gIetcv.gIetcv.gIetcv{height:0;padding-bottom:61.56%;}/*!sc*/ .cqnal.cqnal.cqnal.cqnal{height:0;padding-bottom:102.23%;}/*!sc*/ .jJDuNs.jJDuNs.jJDuNs.jJDuNs{height:0;padding-bottom:57.5%;}/*!sc*/ .gaapxn.gaapxn.gaapxn.gaapxn{height:0;padding-bottom:62.26%;}/*!sc*/ .hGMNlK.hGMNlK.hGMNlK.hGMNlK{height:0;padding-bottom:89.8%;}/*!sc*/ .dAklYm.dAklYm.dAklYm.dAklYm{height:0;padding-bottom:62.81%;}/*!sc*/ .gpcwSq.gpcwSq.gpcwSq.gpcwSq{height:0;padding-bottom:53.96%;}/*!sc*/ .ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .dojQUw.dojQUw.dojQUw.dojQUw{height:0;padding-bottom:50.31%;}/*!sc*/ .iOVeQd.iOVeQd.iOVeQd.iOVeQd{height:0;padding-bottom:80.93%;}/*!sc*/ .dsoriu.dsoriu.dsoriu.dsoriu{height:0;padding-bottom:65%;}/*!sc*/ data-styled.g380[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,fnQDHb,pRYLl,keevkX,bzUfFP,kviAry,blgNiS,ldHUSz,jLYMaS,htBhCB,hygKBp,dfJunC,juZrXb,fHbpUh,ebIGPt,hcsRHl,hpZPQm,iFvLxO,YTIkI,ctaOyT,exFxxY,fOLgRO,irhPHF,ktenGW,eekAZq,evezpr,gkSegO,iCPOVH,hrRtCC,gjAolr,dRaWNy,gIetcv,cqnal,jJDuNs,gaapxn,hGMNlK,dAklYm,gpcwSq,ejnyBo,dojQUw,iOVeQd,dsoriu,\"}/*!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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .lplqa-d.lplqa-d.lplqa-d.lplqa-d{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.lplqa-d.lplqa-d.lplqa-d.lplqa-d{font-size:1.2em!important;}}/*!sc*/ .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*/ .iDNhPI.iDNhPI.iDNhPI.iDNhPI{font-size:9.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.iDNhPI.iDNhPI.iDNhPI.iDNhPI{font-size:3.4em!important;}}/*!sc*/ .eYoKgk.eYoKgk.eYoKgk.eYoKgk{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.eYoKgk.eYoKgk.eYoKgk.eYoKgk{font-size:1.5em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .ghcHLl.ghcHLl.ghcHLl.ghcHLl{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.ghcHLl.ghcHLl.ghcHLl.ghcHLl{font-size:1em!important;}}/*!sc*/ .dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:0.6em!important;}}/*!sc*/ .ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:2.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:6.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:2.4em!important;}}/*!sc*/ .bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:1.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .jsjrYr.jsjrYr.jsjrYr.jsjrYr{font-size:9.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jsjrYr.jsjrYr.jsjrYr.jsjrYr{font-size:3.4em!important;}}/*!sc*/ .bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:1.4em!important;}}/*!sc*/ .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*/ .cVlLEd.cVlLEd.cVlLEd.cVlLEd{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cVlLEd.cVlLEd.cVlLEd.cVlLEd{font-size:1.1em!important;}}/*!sc*/ .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*/ .dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:0.6em!important;}}/*!sc*/ .jkoItf.jkoItf.jkoItf.jkoItf{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jkoItf.jkoItf.jkoItf.jkoItf{font-size:0.7em!important;}}/*!sc*/ .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*/ .ctWqNs.ctWqNs.ctWqNs.ctWqNs{font-size:7em!important;}/*!sc*/ @media only screen and (max-width:640px){.ctWqNs.ctWqNs.ctWqNs.ctWqNs{font-size:2.5em!important;}}/*!sc*/ .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*/ .kmfDed.kmfDed.kmfDed.kmfDed{font-size:8.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kmfDed.kmfDed.kmfDed.kmfDed{font-size:3.1em!important;}}/*!sc*/ .dbonoY.dbonoY.dbonoY.dbonoY{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.dbonoY.dbonoY.dbonoY.dbonoY{font-size:2em!important;}}/*!sc*/ .gpXVuT.gpXVuT.gpXVuT.gpXVuT{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gpXVuT.gpXVuT.gpXVuT.gpXVuT{font-size:2.2em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .inoUtg.inoUtg.inoUtg.inoUtg{font-size:8.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.inoUtg.inoUtg.inoUtg.inoUtg{font-size:3.1em!important;}}/*!sc*/ .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*/ .gnnEgw.gnnEgw.gnnEgw.gnnEgw{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gnnEgw.gnnEgw.gnnEgw.gnnEgw{font-size:1.4em!important;}}/*!sc*/ .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*/ .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*/ .jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:1.8em!important;}}/*!sc*/ .zWscE.zWscE.zWscE.zWscE{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.zWscE.zWscE.zWscE.zWscE{font-size:0.7em!important;}}/*!sc*/ .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*/ .kNhGgX.kNhGgX.kNhGgX.kNhGgX{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kNhGgX.kNhGgX.kNhGgX.kNhGgX{font-size:1.3em!important;}}/*!sc*/ .izSfmh.izSfmh.izSfmh.izSfmh{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.izSfmh.izSfmh.izSfmh.izSfmh{font-size:1.6em!important;}}/*!sc*/ .jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:1.1em!important;}}/*!sc*/ .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*/ .gApunH.gApunH.gApunH.gApunH{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gApunH.gApunH.gApunH.gApunH{font-size:1.8em!important;}}/*!sc*/ .Uccen.Uccen.Uccen.Uccen{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.Uccen.Uccen.Uccen.Uccen{font-size:1.7em!important;}}/*!sc*/ .kukeCs.kukeCs.kukeCs.kukeCs{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kukeCs.kukeCs.kukeCs.kukeCs{font-size:2.2em!important;}}/*!sc*/ .inhdgd.inhdgd.inhdgd.inhdgd{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.inhdgd.inhdgd.inhdgd.inhdgd{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*/ .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*/ .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*/ .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*/ .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*/ .hejuQD.hejuQD.hejuQD.hejuQD{font-size:6.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hejuQD.hejuQD.hejuQD.hejuQD{font-size:2.4em!important;}}/*!sc*/ .eVVsXT.eVVsXT.eVVsXT.eVVsXT{font-size:7.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.eVVsXT.eVVsXT.eVVsXT.eVVsXT{font-size:2.5em!important;}}/*!sc*/ .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*/ .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*/ .XaoDC.XaoDC.XaoDC.XaoDC{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.XaoDC.XaoDC.XaoDC.XaoDC{font-size:2.1em!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*/ .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*/ .cVLSdA.cVLSdA.cVLSdA.cVLSdA{font-size:9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cVLSdA.cVLSdA.cVLSdA.cVLSdA{font-size:3.2em!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*/ .fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:7.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:2.8em!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*/ .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*/ .iITVJY.iITVJY.iITVJY.iITVJY{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iITVJY.iITVJY.iITVJY.iITVJY{font-size:1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .bvXqXn.bvXqXn.bvXqXn.bvXqXn{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvXqXn.bvXqXn.bvXqXn.bvXqXn{font-size:1.4em!important;}}/*!sc*/ .dAsdTT.dAsdTT.dAsdTT.dAsdTT{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dAsdTT.dAsdTT.dAsdTT.dAsdTT{font-size:1.2em!important;}}/*!sc*/ .cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:7em!important;}/*!sc*/ @media only screen and (max-width:640px){.cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:2.4em!important;}}/*!sc*/ .bSbTQU.bSbTQU.bSbTQU.bSbTQU{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bSbTQU.bSbTQU.bSbTQU.bSbTQU{font-size:2.4em!important;}}/*!sc*/ .iNWQSM.iNWQSM.iNWQSM.iNWQSM{font-size:10.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iNWQSM.iNWQSM.iNWQSM.iNWQSM{font-size:3.6em!important;}}/*!sc*/ .fFAiTK.fFAiTK.fFAiTK.fFAiTK{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.fFAiTK.fFAiTK.fFAiTK.fFAiTK{font-size:1.9em!important;}}/*!sc*/ .beQydf.beQydf.beQydf.beQydf{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.beQydf.beQydf.beQydf.beQydf{font-size:1.7em!important;}}/*!sc*/ .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*/ .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*/ .kLBvft.kLBvft.kLBvft.kLBvft{font-size:7.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kLBvft.kLBvft.kLBvft.kLBvft{font-size:2.6em!important;}}/*!sc*/ .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*/ .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*/ .fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:1.2em!important;}}/*!sc*/ .kNAQKA.kNAQKA.kNAQKA.kNAQKA{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kNAQKA.kNAQKA.kNAQKA.kNAQKA{font-size:1.9em!important;}}/*!sc*/ .glOqqI.glOqqI.glOqqI.glOqqI{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.glOqqI.glOqqI.glOqqI.glOqqI{font-size:1.4em!important;}}/*!sc*/ .fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:1.5em!important;}}/*!sc*/ .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*/ .kYsbxS.kYsbxS.kYsbxS.kYsbxS{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kYsbxS.kYsbxS.kYsbxS.kYsbxS{font-size:1.2em!important;}}/*!sc*/ .dHKjeh.dHKjeh.dHKjeh.dHKjeh{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dHKjeh.dHKjeh.dHKjeh.dHKjeh{font-size:1.3em!important;}}/*!sc*/ data-styled.g381[id=\"x__pt8tzk-0\"]{content:\"jfvMWJ,gPIxea,iYgBvA,frzFun,gLHLEv,wpWLG,lplqa-d,jiGVVj,iDNhPI,eYoKgk,gRLJwN,hsPeia,kauVAS,ghcHLl,dDKeDQ,ePuSwO,jtCXvA,iFlEmK,bWSnVS,ldTjgH,bwGQrt,dfserP,fNDhDy,gjHDge,inksEV,dBWQRi,hrVcDN,hPDIHE,jsjrYr,bcCfuJ,dfgvpn,cVlLEd,fjKRAi,dPoeFo,jkoItf,cyVXzf,ctWqNs,iXjdLY,kmfDed,dbonoY,gpXVuT,hbwikt,bwzwBX,cFtCN,jdgMzU,inoUtg,kUqUJf,gnnEgw,gVRWAB,cJcNIn,jFsmoq,zWscE,dyaAfc,kNhGgX,izSfmh,jEhvtw,gALHSm,gApunH,Uccen,kukeCs,inhdgd,jCkLvS,dLwqhJ,hQxAYP,kwLuaB,iNHyie,hejuQD,eVVsXT,dWzMnA,ftetSQ,XaoDC,bNRoJL,gNDiBf,cVLSdA,ijicdz,fZJFvq,bSlVPf,cKlSIC,iITVJY,LzBnW,epoJzD,jfhrCI,bvXqXn,dAsdTT,cUXKOF,bSbTQU,iNWQSM,fFAiTK,beQydf,iCwWtY,jdcGMN,kLBvft,ihkPAv,kMqJSM,fIeyCx,kNAQKA,glOqqI,fTAjeM,jIyTDK,kYsbxS,dHKjeh,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div id=\"apos-netboard3\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer: Maten som bremser fettforbrenningen\" href=\"https://www.dagbladet.no/tema/advarer-maten-som-bremser-fettforbrenningen/81285775\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advarer: Maten som bremser fettforbrenningen\" alt=\"Image: Advarer: Maten som bremser fettforbrenningen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81333114&amp;panow=100&amp;panox=0&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 jfvMWJ title dynamic-sizing\">Advarer: Maten</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">som bremser</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">fettforbrenningen</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Samleiet setter ut reporteren\" href=\"https://www.dagbladet.no/video/settes-ut-vill-fett-fetisj/Y4DujPbh\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Samleiet setter ut reporteren\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81455235.jpg?imageId=81455235&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/23/7bf57cbc-7339-44e9-8599-953df262b072/sex_med_alicegif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/23/7bf57cbc-7339-44e9-8599-953df262b072/sex_med_alicegif.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\">Samleiet setter</span><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">ut reporteren</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=\"Død person funnet i sjøen i Frognerkilen\" href=\"https://www.dagbladet.no/nyheter/dod-person-funnet-i-sjoen-i-frognerkilen/81487793\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Død person funnet i sjøen i Frognerkilen\" alt=\"Image: Død person funnet i sjøen i Frognerkilen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81487798&amp;panow=100&amp;panoy=26.428571428571&amp;panox=0&amp;panoh=50.714285714286&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">Død person funnet i</span><span class=\"x__pt8tzk-0 lplqa-d title dynamic-sizing\">sjøen i Frognerkilen</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=\"Bekreftet: Jose Mourinho presenteres i kveld\" href=\"https://www.dagbladet.no/sport/bekreftet-jose-mourinho-presenteres-i-kveld/81487482\"><figure class=\"x__sc-1an7vu1-0 pRYLl\"><picture><img data-defer=\"view\" title=\"Image: Bekreftet: Jose Mourinho presenteres i kveld\" alt=\"Image: Bekreftet: Jose Mourinho presenteres i kveld\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81487494&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=251&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">Bekreftet: Jose Mourinho</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">presenteres i kveld</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=\"Kobles\" href=\"https://www.dagbladet.no/sport/kobles/81487247\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Kobles\" alt=\"Image: Kobles\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81487250&amp;panoy=14.473684210526&amp;panox=0&amp;panow=100&amp;panoh=46.710526315789&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 iDNhPI title dynamic-sizing\">Kobles</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=\"Advarer: - Joint i 18-årsgave\" href=\"https://www.dagbladet.no/nyheter/advarer-joint-i-18-arsgave/81470679\"><figure class=\"x__sc-1an7vu1-0 keevkX\"><picture><img data-defer=\"view\" title=\"Image: Advarer: - Joint i 18-årsgave\" alt=\"Image: Advarer: - Joint i 18-årsgave\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81476437&amp;panox=0&amp;panow=100&amp;panoh=25.357142857143&amp;panoy=22.857142857143&amp;heighty=21.12676056338&amp;heightx=32.17665615142&amp;heightw=28.391167192429&amp;heighth=34.507042253521&amp;width=485&amp;height=246&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">Advarer: - Joint</span><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">i 18-årsgave</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=\"Nesodden: Krasjer\" href=\"https://www.dagbladet.no/video/nesodden-krasjer/iz9H9Gka\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Nesodden: Krasjer\" alt=\"Image: Nesodden: Krasjer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/iz9H9Gka-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 hsPeia title dynamic-sizing\">Nesodden:</span><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">Krasjer</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=\"Linn (33) fikk sjokkbeskjed: Advarer\" href=\"https://www.dagbladet.no/tema/linn-33-fikk-sjokkbeskjed-advarer/81263652\"><figure class=\"x__sc-1an7vu1-0 bzUfFP\"><picture><img data-defer=\"view\" title=\"Image: Linn (33) fikk sjokkbeskjed: Advarer\" alt=\"Image: Linn (33) fikk sjokkbeskjed: Advarer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81302345&amp;panox=33.333333333333&amp;panow=29.518835042735&amp;panoh=66.878306666667&amp;panoy=18.095238095238&amp;heighty=0.15325655172413&amp;heightx=45.407098121086&amp;heightw=9.31338434238&amp;heighth=100.15325655172&amp;width=320&amp;height=240&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ghcHLl title dynamic-sizing\">Linn (33) fikk</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">sjokkbeskjed: Advarer</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=\"120 000 i demonstrasjon\" href=\"https://www.dagbladet.no/nyheter/120-000-i-demonstrasjon/81486933\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: 120 000 i demonstrasjon\" alt=\"Image: 120 000 i demonstrasjon\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81487146&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ePuSwO title dynamic-sizing\">120 000 i</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">demonstrasjon</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=\"Deler private bilder\" href=\"https://www.dagbladet.no/kjendis/deler-private-bilder/81486842\"><figure class=\"x__sc-1an7vu1-0 blgNiS\"><picture><img data-defer=\"view\" title=\"Image: Deler private bilder\" alt=\"Image: Deler private bilder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81483534&amp;panoy=21.12676056338&amp;panox=0&amp;panow=100&amp;panoh=50&amp;heightw=38.793103448276&amp;heighty=4.4871794871795&amp;heightx=33.189655172414&amp;heighth=93.630573248408&amp;width=402&amp;height=452&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Deler private bilder</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=\"15-åring døde i gokartulykke\" href=\"https://www.dagbladet.no/nyheter/15-aring-dode-i-gokartulykke/81486879\"><figure class=\"x__sc-1an7vu1-0 ldHUSz\"><picture><img data-defer=\"view\" title=\"Image: 15-åring døde i gokartulykke\" alt=\"Image: 15-åring døde i gokartulykke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486942&amp;panow=100&amp;panox=0&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=268&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">15-åring døde</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">i gokartulykke</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=\"Dukket opp\" href=\"https://www.dagbladet.no/sport/dukket-opp/81486696\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dukket opp\" alt=\"Image: Dukket opp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486719&amp;panoy=11.363636363636&amp;panox=0&amp;panow=78.947368421053&amp;panoh=40.340909090909&amp;heightx=24.528301886792&amp;heightw=28.301886792453&amp;heighth=70&amp;heighty=3.3333333333333&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ldTjgH title dynamic-sizing\">Dukket opp</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Seks av sju spenn ødelagt\" href=\"https://www.dagbladet.no/video/-seks-av-sju-spenn-odelagt/nBm27GIO\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Seks av sju spenn ødelagt\" alt=\"Image: - Seks av sju spenn ødelagt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/nBm27GIO-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">- Seks av sju</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">spenn ødelagt</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kari: - Ekstremt uattraktive menn\" href=\"https://www.dagbladet.no/tema/kari-ekstremt-uattraktive-menn/81319789\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><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=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Kari: - Ekstremt</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">uattraktive menn</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-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=\"15-åring angrepet av bjørn i stua\" href=\"https://www.dagbladet.no/nyheter/15-aring-angrepet-av-bjorn-i-stua/81461265\"><figure class=\"x__sc-1an7vu1-0 jLYMaS\"><picture><img data-defer=\"view\" title=\"Image: 15-åring angrepet av bjørn i stua\" alt=\"Image: 15-åring angrepet av bjørn i stua\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81462574&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=267&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\">15-åring angrepet</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">av bjørn i stua</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=\"- Kan ikke tro at dette skjer\" href=\"https://www.dagbladet.no/kjendis/kan-ikke-tro-at-dette-skjer/81457816\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Kan ikke tro at dette skjer\" alt=\"Image: - Kan ikke tro at dette skjer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81455920&amp;panow=49.295774647887&amp;panoh=7.6923076923077&amp;panoy=31.527627302275&amp;panox=46.713615023474&amp;heightx=42.5&amp;heightw=45&amp;heighth=33.870967741935&amp;heighty=28.341013824885&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">- Kan ikke tro</span><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">at dette skjer</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=\"Hjerteskjærende melding\" href=\"https://www.dagbladet.no/sport/hjerteskjaerende-melding-1/81485994\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Hjerteskjærende melding\" alt=\"Image: Hjerteskjærende melding\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486190&amp;panoy=17.117117117117&amp;panox=25.442477876106&amp;panow=46.46017699115&amp;panoh=21.321321321321&amp;heighth=47.727272727273&amp;heighty=5.1948051948052&amp;heightx=38.571428571429&amp;heightw=21.428571428571&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\">Hjerteskjærende</span><span class=\"x__pt8tzk-0 jsjrYr title dynamic-sizing\">melding</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=\"- Kunne vært hodet mitt\" href=\"https://www.dagbladet.no/kjendis/kunne-vaert-hodet-mitt/81486361\"><figure class=\"x__sc-1an7vu1-0 htBhCB\"><picture><img data-defer=\"view\" title=\"Image: - Kunne vært hodet mitt\" alt=\"Image: - Kunne vært hodet mitt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486307&amp;panoy=5.0955414012739&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=45.081388535032&amp;heightx=31.443298969072&amp;heightw=46.277206185567&amp;heighth=99.847794520548&amp;heighty=0&amp;width=402&amp;height=359&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 bcCfuJ title dynamic-sizing\">- Kunne vært</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">hodet mitt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-black\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Hevder norsk fremmedkriger er drept\" href=\"https://www.dagbladet.no/video/ukraina-hevder-norsk-fremmedkriger-er-drept/5PMgovkT\"><figure class=\"x__sc-1an7vu1-0 hygKBp moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Hevder norsk fremmedkriger er drept\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81474777.jpg?imageId=81474777&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=203\" disableremoteplayback=\"\"><source src=\" https://snipp.dbstatic.no/2024/05/30/040833ca-88f1-4324-bec2-d19e12559d2b/nordmanngif1.webm\" type=\"video/webm\"/><source src=\" https://snipp.dbstatic.no/2024/05/30/040833ca-88f1-4324-bec2-d19e12559d2b/nordmanngif1.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 cVlLEd title dynamic-sizing\">Hevder norsk</span><span class=\"x__pt8tzk-0 fjKRAi title dynamic-sizing\">fremmedkriger er drept</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Atopisk eksem kobles til alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/studie-kobler-atopisk-eksem-til-kronisk-sykdom/81334619\"><figure class=\"x__sc-1an7vu1-0 dfJunC\"><picture><img data-defer=\"view\" title=\"Image: Atopisk eksem kobles til alvorlig sykdom\" alt=\"Image: Atopisk eksem kobles til alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80197278&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=221&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Atopisk eksem kobles</span><span class=\"x__pt8tzk-0 jkoItf title dynamic-sizing\">til alvorlig sykdom</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gladnyhet til deg som er glad i disse\" href=\"https://tinyurl.com/energidrikke2?allerID=1202405071\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Gladnyhet til deg som er glad i disse\" alt=\"Image: Gladnyhet til deg som er glad i disse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81366836.jpg?imageId=81366836&amp;x=0.000000&amp;y=8.166969&amp;cropw=100.000000&amp;croph=80.036298&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">Gladnyhet til deg</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">som er glad i disse</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bekrefter\" href=\"https://www.dagbladet.no/sport/bekrefter/81486312\"><figure class=\"x__sc-1an7vu1-0 juZrXb\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter\" alt=\"Image: Bekrefter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486318&amp;panoy=20.714285714286&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=344&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">Bekrefter</span></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=\"26 fjellklatrere snøfast\" href=\"https://www.dagbladet.no/nyheter/26-fjellklatrere-snofast/81486270\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: 26 fjellklatrere snøfast\" alt=\"Image: 26 fjellklatrere snøfast\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486275&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&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 iXjdLY title dynamic-sizing\">26 fjellklatrere</span><span class=\"x__pt8tzk-0 kmfDed title dynamic-sizing\">snøfast</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Overrasker: - Kriminelt\" href=\"https://www.dagbladet.no/kjendis/overrasker-kriminelt/81485667\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Overrasker: - Kriminelt\" alt=\"Image: Overrasker: - Kriminelt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81485863&amp;panox=0.15723301886793&amp;panoy=16.603773584906&amp;panow=99.842766981132&amp;panoh=27.421383396226&amp;heightx=40.697674418605&amp;heightw=35.529715503876&amp;heighth=46.313603115265&amp;heighty=15.576323987539&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 dbonoY title dynamic-sizing\">Overrasker:</span><span class=\"x__pt8tzk-0 gpXVuT title dynamic-sizing\">- Kriminelt</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=\"- Avhengig av hverandre\" href=\"https://www.dagbladet.no/kjendis/avhengig-av-hverandre/81481205\"><figure class=\"x__sc-1an7vu1-0 fHbpUh\"><picture><img data-defer=\"view\" title=\"Image: - Avhengig av hverandre\" alt=\"Image: - Avhengig av hverandre\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80029427&amp;panoy=19.365079365079&amp;panox=0&amp;panow=100&amp;panoh=22.539682539683&amp;heighty=0&amp;heightw=61.224489795918&amp;heighth=66.216216216216&amp;heightx=15.646258503401&amp;width=485&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 hbwikt title dynamic-sizing\">- Avhengig</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">av hverandre</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard5\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Magefett-formelen: Borte på 10 uker\" href=\"https://www.dagbladet.no/tema/magefett-formelen-borte-pa-10-uker/81344415\"><figure class=\"x__sc-1an7vu1-0 ebIGPt\"><picture><img data-defer=\"view\" title=\"Image: Magefett-formelen: Borte på 10 uker\" alt=\"Image: Magefett-formelen: Borte på 10 uker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81351187&amp;panoy=4.040404040404&amp;panox=29.263913824057&amp;panow=37.795066068223&amp;panoh=72.240927272727&amp;heightw=8.1349793777778&amp;heighth=74.259259&amp;heighty=3&amp;heightx=50.222222222222&amp;width=320&amp;height=169&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\">Magefett-formelen:</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">Borte på 10 uker</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russerne gjemmer seg - angripes\" href=\"https://www.dagbladet.no/video/russerne-gjemmer-seg-angripes/kKm4JfqP\"><figure class=\"x__sc-1an7vu1-0 ebIGPt\"><picture><img data-defer=\"view\" title=\"Image: Russerne gjemmer seg - angripes\" alt=\"Image: Russerne gjemmer seg - angripes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kKm4JfqP-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\">Russerne gjemmer</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">seg - angripes</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=\"Avis: Slo full alarm\" href=\"https://www.dagbladet.no/sport/avis-slo-full-alarm/81486144\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Avis: Slo full alarm\" alt=\"Image: Avis: Slo full alarm\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486147&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Avis: Slo</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">full alarm</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=\"Forbyr bruk av hitlåt\" href=\"https://www.dagbladet.no/sport/forbyr-bruk-av-hitlat/81485885\"><figure class=\"x__sc-1an7vu1-0 hcsRHl\"><picture><img data-defer=\"view\" title=\"Image: Forbyr bruk av hitlåt\" alt=\"Image: Forbyr bruk av hitlåt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81485911&amp;panox=7.2033898305085&amp;panow=88.983050847458&amp;panoh=45.222929936306&amp;panoy=54.777070063694&amp;heighty=0&amp;heightx=27.601809954751&amp;heightw=40.723981900452&amp;heighth=100&amp;width=402&amp;height=369&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\">Forbyr bruk</span><span class=\"x__pt8tzk-0 ldTjgH title dynamic-sizing\">av hitlåt</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=\"- Tom for ord\" href=\"https://www.dagbladet.no/nyheter/tom-for-ord/81485982\"><figure class=\"x__sc-1an7vu1-0 hpZPQm\"><picture><img data-defer=\"view\" title=\"Image: - Tom for ord\" alt=\"Image: - Tom for ord\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81486004&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=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 gnnEgw title dynamic-sizing\">- Tom for ord</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=\"Gutten funnet død\" href=\"https://www.dagbladet.no/nyheter/gutten-funnet-dod/81485509\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Gutten funnet død\" alt=\"Image: Gutten funnet død\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484692&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">Gutten funnet død</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=\"Sjokkerer familien\" href=\"https://www.dagbladet.no/video/sjokkerer-familien/RkKVIaPH\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Sjokkerer familien\" alt=\"Image: Sjokkerer familien\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/RkKVIaPH-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cJcNIn title dynamic-sizing\">Sjokkerer</span><span class=\"x__pt8tzk-0 jFsmoq title dynamic-sizing\">familien</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=\"Grepet som fjerner pigmentflekkene\" href=\"https://www.dagbladet.no/tema/grepet-som-fjerner-pigmentflekkene/81428703\"><figure class=\"x__sc-1an7vu1-0 iFvLxO\"><picture><img data-defer=\"view\" title=\"Image: Grepet som fjerner pigmentflekkene\" alt=\"Image: Grepet som fjerner pigmentflekkene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81428716&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=36.734693877551&amp;heightw=45.918367346939&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=239&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Grepet som fjerner</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">pigmentflekkene</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tilbud på unikt luksushotell\" href=\"https://www.dagbladet.no/annonse/slik-reiser-du-billig-til-syden/81329020?allerID=1202413054\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Tilbud på unikt luksushotell\" alt=\"Image: Tilbud på unikt luksushotell\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81473908.jpg?imageId=81473908&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Tilbud på unikt</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">luksushotell</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Hun har vært utrolig viktig\" href=\"https://www.dagbladet.no/kjendis/hun-har-vaert-utrolig-viktig/81482007\"><figure class=\"x__sc-1an7vu1-0 YTIkI\"><picture><img data-defer=\"view\" title=\"Image: - Hun har vært utrolig viktig\" alt=\"Image: - Hun har vært utrolig viktig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81485638&amp;panoy=19.636363636364&amp;panox=0&amp;panow=99.842766981132&amp;panoh=26.424242181818&amp;heightw=80.409356140351&amp;heighth=99.77628590604&amp;heighty=0&amp;heightx=11.40350877193&amp;width=402&amp;height=223&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">- Hun har vært</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">utrolig viktig</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=\"- Din tjukke jævel\" href=\"https://www.dagbladet.no/sport/din-tjukke-jaevel/81485366\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Din tjukke jævel\" alt=\"Image: - Din tjukke jævel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81485505&amp;panoy=17.67955801105&amp;panow=78.947368421053&amp;panoh=39.226519337017&amp;panox=11.278195488722&amp;heighty=4.040404040404&amp;heightx=37.241379310345&amp;heightw=31.034482758621&amp;heighth=74.242424242424&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 izSfmh title dynamic-sizing\">- Din tjukke jævel</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=\"Opplevde feriemarerittet: Sporløst borte\" href=\"https://www.dagbladet.no/nyheter/opplevde-feriemarerittet-sporlost-borte/81460238\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Opplevde feriemarerittet: Sporløst borte\" alt=\"Image: Opplevde feriemarerittet: Sporløst borte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81475945&amp;panox=0&amp;panow=99.842766981132&amp;panoh=25.677267137809&amp;panoy=31.448763250883&amp;heighty=3.3707865168539&amp;heightx=20.300751879699&amp;heightw=68.922305263158&amp;heighth=83.520598876404&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 jEhvtw title dynamic-sizing\">Opplevde feriemarerittet:</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">Sporløst borte</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 bekymring rundt Foxtrot\" href=\"https://www.dagbladet.no/nyheter/har-bekymring-rundt-foxtrot/81482196\"><figure class=\"x__sc-1an7vu1-0 ctaOyT\"><picture><img data-defer=\"view\" title=\"Image: - Har bekymring rundt Foxtrot\" alt=\"Image: - Har bekymring rundt Foxtrot\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81482648&amp;panoy=38.928571428571&amp;panox=0&amp;panow=100&amp;panoh=25.357142857143&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=402&amp;height=297&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">- Har bekymring</span><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">rundt Foxtrot</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 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=\"Overrasker i norsk design\" href=\"https://www.dagbladet.no/kjendis/overrasker-i-norsk-design/81479960\"><figure class=\"x__sc-1an7vu1-0 pRYLl\"><picture><img data-defer=\"view\" title=\"Image: Overrasker i norsk design\" alt=\"Image: Overrasker i norsk design\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81479734&amp;panoy=5&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=28.506787330317&amp;width=485&amp;height=251&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 gALHSm title dynamic-sizing\">Overrasker i</span><span class=\"x__pt8tzk-0 gApunH title dynamic-sizing\">norsk design</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=\"Gambler med ansettelse\" href=\"https://www.dagbladet.no/sport/kontrollfreaken/81433230\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Gambler med ansettelse\" alt=\"Image: Gambler med ansettelse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81433338&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=22.857142857143&amp;panox=0&amp;heighty=0&amp;heightx=33.031674208145&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 Uccen title dynamic-sizing\">Gambler med</span><span class=\"x__pt8tzk-0 kukeCs title dynamic-sizing\">ansettelse</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=\"En person besvimte\" href=\"https://www.dagbladet.no/kjendis/en-person-besvimte/81485191\"><figure class=\"x__sc-1an7vu1-0 exFxxY\"><picture><img data-defer=\"view\" title=\"Image: En person besvimte\" alt=\"Image: En person besvimte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81485346&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=214&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 inhdgd title dynamic-sizing\">En person</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">besvimte</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=\"Splittelsen\" href=\"https://www.dagbladet.no/nyheter/splittelsen/81463511\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Splittelsen\" alt=\"Image: Splittelsen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81482224&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=5.5900621118012&amp;heightx=34.965034965035&amp;heightw=31.468531468531&amp;heighth=91.304347826087&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 jCkLvS title dynamic-sizing\">Splittelsen</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=\"Så mye øker din uføretrygd\" href=\"https://www.dagbladet.no/tema/sa-mye-oker-din-uforetrygd/81399777\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Så mye øker din uføretrygd\" alt=\"Image: Så mye øker din uføretrygd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81399809&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=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\">Så mye øker</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">din uføretrygd</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=\"Kommer fra dypet\" href=\"https://www.dagbladet.no/video/kommer-fra-dypet/7YeC3g1K\"><figure class=\"x__sc-1an7vu1-0 fOLgRO\"><picture><img data-defer=\"view\" title=\"Image: Kommer fra dypet\" alt=\"Image: Kommer fra dypet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/7YeC3g1K-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Kommer fra dypet</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=\"Fotballbombe: - Glad\" href=\"https://www.dagbladet.no/sport/fotballbombe-glad/81484670\"><figure class=\"x__sc-1an7vu1-0 irhPHF\"><picture><img data-defer=\"view\" title=\"Image: Fotballbombe: - Glad\" alt=\"Image: Fotballbombe: - Glad\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484674&amp;panow=33.548040901771&amp;panoh=17.230273913043&amp;panoy=15.700483091787&amp;panox=28.502415458937&amp;heightx=26.027397260274&amp;heightw=40.791476712329&amp;heighth=100.2283109589&amp;heighty=0.22831095890411&amp;width=485&amp;height=304&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Fotballbombe: - Glad</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bekrefter avgjørelse: - Skremmer meg\" href=\"https://www.dagbladet.no/sport/min-tid-er-snart-over/81473008\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter avgjørelse: - Skremmer meg\" alt=\"Image: Bekrefter avgjørelse: - Skremmer meg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81473399&amp;panoy=28.17679558011&amp;panow=76.756536764706&amp;panoh=39.103745856354&amp;panox=18.75&amp;heighty=11.004784688995&amp;heightx=44.728434504792&amp;heightw=28.682996805112&amp;heighth=69.750133971292&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 jEhvtw title dynamic-sizing\">Bekrefter avgjørelse:</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">- Skremmer meg</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=\"Amper stemning: Aksjonister stengte veien\" href=\"https://www.dagbladet.no/nyheter/amper-stemning-aksjonister-stengte-veien/81485198\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Amper stemning: Aksjonister stengte veien\" alt=\"Image: Amper stemning: Aksjonister stengte veien\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81485203&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 kNhGgX title dynamic-sizing\">Amper stemning:</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">Aksjonister</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">stengte veien</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=\"Døde i tragisk ulykke\" href=\"https://www.dagbladet.no/sport/dode-i-tragisk-ulykke/81452657\"><figure class=\"x__sc-1an7vu1-0 ktenGW\"><picture><img data-defer=\"view\" title=\"Image: Døde i tragisk ulykke\" alt=\"Image: Døde i tragisk ulykke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484941&amp;panoy=4.0816326530612&amp;panox=10.288065843621&amp;panow=86.41975308642&amp;panoh=36.224489795918&amp;heightw=28.03738317757&amp;heighth=56.976744186047&amp;heightx=39.8753894081&amp;heighty=2.7131782945736&amp;width=485&amp;height=424&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Døde i tragisk ulykke</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard6\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Politiet advarer turgåere\" href=\"https://www.dagbladet.no/video/politiet-advarer-turgaere/uzkKxP4P\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Politiet advarer turgåere\" alt=\"Image: Politiet advarer turgåere\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uzkKxP4P-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 kauVAS title dynamic-sizing\">Politiet</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">advarer turgåere</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=\"Studie: Tre setninger avslører narsissisten\" href=\"https://www.dagbladet.no/tema/studie-tre-setninger-avslorer-narsissisten/81361047\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Studie: Tre setninger avslører narsissisten\" alt=\"Image: Studie: Tre setninger avslører narsissisten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81367601&amp;panow=99.893674641148&amp;panoy=17.26618705036&amp;panox=0&amp;panoh=50.91926618705&amp;heightw=40.994420091324&amp;heighth=99.847794520548&amp;heighty=0&amp;heightx=21.917808219178&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Studie: Tre setninger</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">avslører narsissisten</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=\"Druknet: 14-åringer prøvde å redde\" href=\"https://www.dagbladet.no/nyheter/druknet-14-aringer-provde-a-redde/81485150\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Druknet: 14-åringer prøvde å redde\" alt=\"Image: Druknet: 14-åringer prøvde å redde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81485172&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=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 dLwqhJ title dynamic-sizing\">Druknet: 14-åringer</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">prøvde å redde</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bjørgen slår alarm\" href=\"https://www.dagbladet.no/sport/bjorgen-slar-alarm/81479395\"><figure class=\"x__sc-1an7vu1-0 eekAZq\"><picture><img data-defer=\"view\" title=\"Image: Bjørgen slår alarm\" alt=\"Image: Bjørgen slår alarm\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81480359&amp;panox=21.542553191489&amp;panow=55.526005319149&amp;panoh=28.311112&amp;panoy=38&amp;heightx=40.34749034749&amp;heighty=30.523255813953&amp;heightw=17.331617760618&amp;heighth=42.377261627907&amp;width=402&amp;height=228&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hejuQD title dynamic-sizing\">Bjørgen</span><span class=\"x__pt8tzk-0 gALHSm title dynamic-sizing\">slår alarm</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=\"Sparket etter dette\" href=\"https://www.dagbladet.no/nyheter/sparket-etter-dette/81484926\"><figure class=\"x__sc-1an7vu1-0 evezpr\"><picture><img data-defer=\"view\" title=\"Image: Sparket etter dette\" alt=\"Image: Sparket etter dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484933&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=402&amp;height=259&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eVVsXT title dynamic-sizing\">Sparket</span><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">etter dette</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=\"- Var ikke godt nok forberedt\" href=\"https://www.dagbladet.no/kjendis/var-ikke-godt-nok-forberedt/81483353\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Var ikke godt nok forberedt\" alt=\"Image: - Var ikke godt nok forberedt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484061&amp;panow=99.842766981132&amp;panoh=46.284500636943&amp;panoy=38.853503184713&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">- Var ikke godt</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">nok forberedt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"NRK beklager etter dette\" href=\"https://www.dagbladet.no/video/solvang-beklager/dNL08ihD\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: NRK beklager etter dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81465003.jpg?imageId=81465003&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/29/901f89cc-e093-4b6b-8026-21f63c45d951/solvang_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/29/901f89cc-e093-4b6b-8026-21f63c45d951/solvang_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 cVlLEd title dynamic-sizing\">NRK beklager</span><span class=\"x__pt8tzk-0 gnnEgw title dynamic-sizing\">etter dette</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Lindas (36) oppskrift: Kiloene renner av!\" href=\"https://www.dagbladet.no/tema/lindas-36-oppskriftkiloene-renner-av/81308092\"><figure class=\"x__sc-1an7vu1-0 gkSegO\"><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=9.3457943925234&amp;panox=32.950819672131&amp;panow=33.688524590164&amp;panoh=64.953271028037&amp;heightx=52.401746724891&amp;heightw=7.5109170305677&amp;heighth=70.5&amp;heighty=0&amp;width=320&amp;height=211&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Lindas (36) oppskrift:</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Kiloene renner av!</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=\"- Har fått mange trusler\" href=\"https://www.dagbladet.no/kjendis/har-fatt-mange-trusler/81460769\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Har fått mange trusler\" alt=\"Image: - Har fått mange trusler\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=72305893&amp;panoy=1.1976047904192&amp;panox=11.020438247012&amp;panow=81.872509960159&amp;panoh=41.616766467066&amp;heighty=4.1379310344828&amp;heightw=20.642201834862&amp;heighth=50.689655172414&amp;heightx=20.412844036697&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 jCkLvS title dynamic-sizing\">- Har fått</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">mange trusler</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kan gjøre ting komplisert\" href=\"https://www.dagbladet.no/sport/kan-gjore-ting-komplisert/81406977\"><figure class=\"x__sc-1an7vu1-0 iCPOVH\"><picture><img data-defer=\"view\" title=\"Image: - Kan gjøre ting komplisert\" alt=\"Image: - Kan gjøre ting komplisert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81406980&amp;panox=48.905109489051&amp;panow=51.094890510949&amp;panoh=25.912408759124&amp;panoy=26.582580291971&amp;heighth=50.752351034483&amp;heighty=22.068965517241&amp;heightx=62.614678899083&amp;heightw=20.683903211009&amp;width=485&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 XaoDC title dynamic-sizing\">- Kan gjøre</span><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">ting komplisert</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=\"Fortsetter søket: - Håp om funn\" href=\"https://www.dagbladet.no/nyheter/fortsetter-soket-hap-om-funn/81484157\"><figure class=\"x__sc-1an7vu1-0 hrRtCC\"><picture><img data-defer=\"view\" title=\"Image: Fortsetter søket: - Håp om funn\" alt=\"Image: Fortsetter søket: - Håp om funn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484692&amp;panox=0&amp;panoy=18.620689655172&amp;panow=100&amp;panoh=51.034482758621&amp;heighty=0&amp;heightx=1.0526315789474&amp;heightw=98.947368421053&amp;heighth=98.709677419355&amp;width=402&amp;height=419&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\">Fortsetter søket:</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">- Håp om funn</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=\"- Dramatisk utvikling\" href=\"https://www.dagbladet.no/nyheter/dramatisk-utvikling/81484769\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Dramatisk utvikling\" alt=\"Image: - Dramatisk utvikling\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81478005&amp;panoy=22.58064516129&amp;panox=8.1545064377682&amp;panow=89.055793991416&amp;panoh=46.129032258065&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gNDiBf title dynamic-sizing\">- Dramatisk</span><span class=\"x__pt8tzk-0 cVLSdA title dynamic-sizing\">utvikling</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard7\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Venninnas uro: Den siste samtalen\" href=\"https://www.dagbladet.no/nyheter/venninnas-uro-den-siste-samtalen/81321361\"><figure class=\"x__sc-1an7vu1-0 gjAolr\"><picture><img data-defer=\"view\" title=\"Image: Venninnas uro: Den siste samtalen\" alt=\"Image: Venninnas uro: Den siste samtalen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76828491&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=172&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Venninnas uro:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Den siste samtalen</span></h3></header></a></article><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=\"Ukrainsk missilangrep: - Over 100 drept\" href=\"https://www.dagbladet.no/video/ukrainsk-missilangrep-over-100-drept/wWGsrDHF\"><figure class=\"x__sc-1an7vu1-0 gjAolr\"><picture><img data-defer=\"view\" title=\"Image: Ukrainsk missilangrep: - Over 100 drept\" alt=\"Image: Ukrainsk missilangrep: - Over 100 drept\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/wWGsrDHF-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Ukrainsk missilangrep:</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">- Over 100 drept</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vekker sinne i Russland\" href=\"https://www.dagbladet.no/nyheter/vekker-sinne-i-russland/81484752\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Vekker sinne i Russland\" alt=\"Image: Vekker sinne i Russland\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484755&amp;panoy=14.627659574468&amp;panox=17.813051146384&amp;panow=36.596119929453&amp;panoh=19.015957446809&amp;heightx=28.824476650564&amp;heightw=14.573268921095&amp;heighth=35.644768856448&amp;heighty=3.6496350364963&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 bwzwBX title dynamic-sizing\">Vekker sinne</span><span class=\"x__pt8tzk-0 kukeCs title dynamic-sizing\">i Russland</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ny beskjed: Utsatt\" href=\"https://www.dagbladet.no/sport/ny-beskjed-utsatt/81484676\"><figure class=\"x__sc-1an7vu1-0 dRaWNy\"><picture><img data-defer=\"view\" title=\"Image: Ny beskjed: Utsatt\" alt=\"Image: Ny beskjed: Utsatt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484726&amp;panoy=2.5735294117647&amp;panox=31.051344743276&amp;panow=50.733496332518&amp;panoh=26.286764705882&amp;heighty=3.0716723549488&amp;heightw=10.214446952596&amp;heighth=25&amp;heightx=37.020316027088&amp;width=485&amp;height=368&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\">Ny beskjed: Utsatt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Storskjermen avslørte detalj\" href=\"https://www.dagbladet.no/video/storskjermen-avslorte-detalj/M6oHsTPY\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Storskjermen avslørte detalj\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81461902.jpg?imageId=81461902&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/16/9f86dbc3-74f6-45e6-adb3-a23b705b1b57/gif_ivers.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/16/9f86dbc3-74f6-45e6-adb3-a23b705b1b57/gif_ivers.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 cVlLEd title dynamic-sizing\">Storskjermen</span><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">avslørte detalj</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=\"IBS: Ukjent behandling hjelper 70 prosent\" href=\"https://www.dagbladet.no/tema/ibs-ukjent-behandling-hjelper-70-prosent/81067452\"><figure class=\"x__sc-1an7vu1-0 gIetcv\"><picture><img data-defer=\"view\" title=\"Image: IBS: Ukjent behandling hjelper 70 prosent\" alt=\"Image: IBS: Ukjent behandling hjelper 70 prosent\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81333283&amp;panoy=9.2198581560284&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=320&amp;height=197&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">IBS: Ukjent behandling</span><span class=\"x__pt8tzk-0 jkoItf title dynamic-sizing\">hjelper 70 prosent</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=\"Deler trist beskjed\" href=\"https://www.dagbladet.no/nyheter/deler-trist-beskjed/81484686\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Deler trist beskjed\" alt=\"Image: Deler trist beskjed\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484698&amp;panoy=0&amp;panox=3.6437246963563&amp;panow=84.008097165992&amp;panoh=43.333333333333&amp;heighty=0&amp;heightw=37.551867219917&amp;heighth=91.5625&amp;heightx=20.746887966805&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 fZJFvq title dynamic-sizing\">Deler trist</span><span class=\"x__pt8tzk-0 bSlVPf title dynamic-sizing\">beskjed</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=\"- Må regne med kritikk\" href=\"https://www.dagbladet.no/kjendis/ma-regne-med-kritikk/81462463\"><figure class=\"x__sc-1an7vu1-0 cqnal\"><picture><img data-defer=\"view\" title=\"Image: - Må regne med kritikk\" alt=\"Image: - Må regne med kritikk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81476573&amp;panoy=7.0512820512821&amp;panox=0&amp;panow=100&amp;panoh=22.75641025641&amp;heighty=0&amp;heightw=56.962025316456&amp;heighth=62.28813559322&amp;heightx=21.518987341772&amp;width=402&amp;height=411&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">- Må regne</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">med kritikk</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard8\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Metoden: - Lært meg å takle angsten\" href=\"https://www.dagbladet.no/tema/metoden-laert-meg-a-takle-angsten/81336535\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Metoden: - Lært meg å takle angsten\" alt=\"Image: Metoden: - Lært meg å takle angsten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81350201&amp;panoy=8.9735922330097&amp;panox=0&amp;panow=100&amp;panoh=23.948220064725&amp;heighty=0&amp;heightx=11.650485436893&amp;heightw=87.162893203884&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 fNDhDy title dynamic-sizing\">Metoden: - Lært</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">meg å takle angsten</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ikke vist på NRK: - Pinlig!\" href=\"https://www.dagbladet.no/video/ikke-vist-pa-nrk-pinlig/TYyV2yMs\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Ikke vist på NRK: - Pinlig!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81478687.jpg?imageId=81478687&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/30/fda6083c-f113-4339-ae5e-cd9a4e07880b/gif_groevdal.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/30/fda6083c-f113-4339-ae5e-cd9a4e07880b/gif_groevdal.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 cKlSIC title dynamic-sizing\">Ikke vist på</span><span class=\"x__pt8tzk-0 cVlLEd title dynamic-sizing\">NRK: - Pinlig!</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Daniel skulle undersøke\" href=\"https://www.dagbladet.no/video/daniel-skulle-undersoke/87CtNNVt\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Daniel skulle undersøke\" alt=\"Image: Daniel skulle undersøke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/87CtNNVt-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Daniel skulle</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">undersøke</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=\"Kuttet to ting: Kim ned 20 kilo\" href=\"https://www.dagbladet.no/tema/kuttet-to-ting-kim-ned-20-kilo/81333973\"><figure class=\"x__sc-1an7vu1-0 jJDuNs\"><picture><img data-defer=\"view\" title=\"Image: Kuttet to ting: Kim ned 20 kilo\" alt=\"Image: Kuttet to ting: Kim ned 20 kilo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=79792392&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=49.54128440367&amp;heightw=13.608562691131&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=184&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 iITVJY title dynamic-sizing\">Kuttet to ting:</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Kim ned 20 kilo</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=\"Sagd ned før Pride-flagging: - Trist\" href=\"https://www.dagbladet.no/nyheter/sagd-ned-for-pride-flagging-trist/81484348\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Sagd ned før Pride-flagging: - Trist\" alt=\"Image: Sagd ned før Pride-flagging: - Trist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484440&amp;panow=57.065217391304&amp;panoy=11.004784688995&amp;panox=22.826086956522&amp;panoh=33.971291866029&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 jtCXvA title dynamic-sizing\">Sagd ned før</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Pride-flagging: - Trist</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=\"- Et siste farvel\" href=\"https://www.dagbladet.no/sport/et-siste-farvel/81483493\"><figure class=\"x__sc-1an7vu1-0 gaapxn\"><picture><img data-defer=\"view\" title=\"Image: - Et siste farvel\" alt=\"Image: - Et siste farvel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81483504&amp;panow=100&amp;panoh=33.177570093458&amp;panoy=15.88785046729&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=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 LzBnW title dynamic-sizing\">- Et siste farvel</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Minus 14 kilo på ti uker\" href=\"https://www.dagbladet.no/tema/ned-14-kilo-pa-ti-uker/81309701\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Minus 14 kilo på ti uker\" alt=\"Image: Minus 14 kilo på ti uker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81320638&amp;panoy=6.2068965517241&amp;panow=31.84573&amp;panoh=49.780564137931&amp;panox=34.545454545455&amp;heighty=0.12368571428571&amp;heightx=43.267776096823&amp;heightw=13.622631117825&amp;heighth=100.12368571429&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Minus 14 kilo</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">på ti uker</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Unner ikke min verste fiende dette!\" href=\"https://www.dagbladet.no/video/prover-mensensmertesimulator-ta-deg-sammen/GpaMf4gU\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: - Unner ikke min verste fiende dette!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81464867.jpg?imageId=81464867&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/28/9f620c3d-310a-43b7-9185-06c82b65fa36/gif_mens.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/28/9f620c3d-310a-43b7-9185-06c82b65fa36/gif_mens.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\">- Unner ikke</span><span class=\"x__pt8tzk-0 bvXqXn title dynamic-sizing\">min verste</span><span class=\"x__pt8tzk-0 dAsdTT title dynamic-sizing\">fiende dette!</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=\"- Jeg er sjokkskada\" href=\"https://www.dagbladet.no/kjendis/jeg-er-sjokkskada/81482851\"><figure class=\"x__sc-1an7vu1-0 hGMNlK\"><picture><img data-defer=\"view\" title=\"Image: - Jeg er sjokkskada\" alt=\"Image: - Jeg er sjokkskada\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484400&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=402&amp;height=361&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 cUXKOF title dynamic-sizing\">- Jeg er</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">sjokkskada</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=\"Fikk dårlige nyheter\" href=\"https://www.dagbladet.no/sport/fikk-darlige-nyheter/81484219\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Fikk dårlige nyheter\" alt=\"Image: Fikk dårlige nyheter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81484309&amp;panow=100.16025673077&amp;panoh=57.994580487805&amp;panox=0.16025673076923&amp;panoy=5.6910569105691&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bSbTQU title dynamic-sizing\">Fikk dårlige</span><span class=\"x__pt8tzk-0 iNWQSM title dynamic-sizing\">nyheter</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=\"Advarer russerne\" href=\"https://www.dagbladet.no/video/advarer-russerne/YV1HwaxQ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advarer russerne\" alt=\"Image: Advarer russerne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/YV1HwaxQ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">Advarer</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">russerne</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"«Du er heldigvis pen, da»\" href=\"https://www.dagbladet.no/tema/alle-tror-jeg-skal-drepe-dem/81237848\"><figure class=\"x__sc-1an7vu1-0 dAklYm\"><picture><img data-defer=\"view\" title=\"Image: «Du er heldigvis pen, da»\" alt=\"Image: «Du er heldigvis pen, da»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81281549&amp;panox=0&amp;panow=100&amp;panoh=25.622775800712&amp;panoy=8.1647900355872&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=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 fNDhDy title dynamic-sizing\">«Du er heldigvis</span><span class=\"x__pt8tzk-0 beQydf title dynamic-sizing\">pen, da»</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 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=\"Gutten med maska\" href=\"https://www.dagbladet.no/nyheter/gutten-med-masken/81338410\"><figure class=\"x__sc-1an7vu1-0 gpcwSq\"><picture><img data-defer=\"view\" title=\"Image: Gutten med maska\" alt=\"Image: Gutten med maska\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339455&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panoy=24.113475177305&amp;panox=0.15723301886793&amp;heighty=0.22371409395974&amp;heightx=8.9285714285714&amp;heightw=40.92261875&amp;heighth=99.77628590604&amp;width=567&amp;height=306&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iCwWtY title dynamic-sizing\">Gutten med maska</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=\"- Ble torturert til døde\" href=\"https://www.dagbladet.no/sport/ble-torturert-til-dode/81481862\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Ble torturert til døde\" alt=\"Image: - Ble torturert til døde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81482031&amp;panox=0&amp;panow=100&amp;panoh=59.166666666667&amp;panoy=0&amp;heighty=0&amp;heightx=18.604651162791&amp;heightw=34.883720930233&amp;heighth=100&amp;width=402&amp;height=201&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">- Ble torturert</span><span class=\"x__pt8tzk-0 kLBvft title dynamic-sizing\">til døde</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard10\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard10\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ferie-fellene: Pengene du kan få\" href=\"https://www.dagbladet.no/tema/ferie-fellene-pengene-du-kan-fa/81446670\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Ferie-fellene: Pengene du kan få\" alt=\"Image: Ferie-fellene: Pengene du kan få\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81448013&amp;panoy=31.446540880503&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=45.702305660377&amp;heightx=15.151515151515&amp;heightw=46.296295959596&amp;heighth=99.77628590604&amp;heighty=0.22371409395974&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 epoJzD title dynamic-sizing\">Ferie-fellene:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Pengene du kan få</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russerne i overtall - så skjer dette\" href=\"https://www.dagbladet.no/video/russerne-i-overtall-sa-skjer-dette/LrLwAA2k\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Russerne i overtall - så skjer dette\" alt=\"Image: Russerne i overtall - så skjer dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/LrLwAA2k-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\">Russerne i overtall</span><span class=\"x__pt8tzk-0 iFlEmK 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-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=\"Ser ulven - så kommer sjokket\" href=\"https://www.dagbladet.no/video/ser-ulven-sa-kommer-sjokket/pr7jdk7J\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ser ulven - så kommer sjokket\" alt=\"Image: Ser ulven - så kommer sjokket\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/pr7jdk7J-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\">Ser ulven - så</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">kommer sjokket</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=\"Frokostknepet:- Kiloene raser!\" href=\"https://www.dagbladet.no/tema/frokostknepet-kiloene-raser/81456297\"><figure class=\"x__sc-1an7vu1-0 dojQUw\"><picture><img data-defer=\"view\" title=\"Image: Frokostknepet:- Kiloene raser!\" alt=\"Image: Frokostknepet:- Kiloene raser!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81458555&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=320&amp;height=161&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 ihkPAv title dynamic-sizing\">Frokostknepet:-</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Kiloene raser!</span></h3></header></a></article><div id=\"apos-medium-rectangle9\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard11\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"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-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=\"Dras ut: - Legg den tilbake!\" href=\"https://www.dagbladet.no/video/dras-ut-legg-den-tilbake/FqMTa3nK\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Dras ut: - Legg den tilbake!\" alt=\"Image: Dras ut: - Legg den tilbake!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/FqMTa3nK-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 iFlEmK title dynamic-sizing\">Dras ut: - Legg</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">den tilbake!</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kastet ut av NRK-debatt: - Ødela mye\" href=\"https://www.dagbladet.no/video/kastet-ut-av-nrk-debatt-odela-mye/kYqjsS6r\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Kastet ut av NRK-debatt: - Ødela mye\" alt=\"Image: Kastet ut av NRK-debatt: - Ødela mye\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kYqjsS6r-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">Kastet ut av</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">NRK-debatt:</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">- Ødela mye</span></h3></header></a></article><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=\"Utroskap: Hvorfor skjer det med meg?\" href=\"https://www.dagbladet.no/tema/utroskap-hvorforskjer-det-med-meg/81206139\"><figure class=\"x__sc-1an7vu1-0 iOVeQd\"><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=259&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 id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kom hjem til dette\" href=\"https://www.dagbladet.no/video/kom-hjem-til-dette/Wpf4L3Vo\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Kom hjem til dette\" alt=\"Image: Kom hjem til dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Wpf4L3Vo-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">Kom hjem</span><span class=\"x__pt8tzk-0 kNAQKA title dynamic-sizing\">til dette</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ekspertens fibromyalgi-advarsel\" href=\"https://www.dagbladet.no/tema/hannes-49-fibromyalgi-grep-naermere-frisk/81268765\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ekspertens fibromyalgi-advarsel\" alt=\"Image: Ekspertens fibromyalgi-advarsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81275393&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Ekspertens</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">fibromyalgi-advarsel</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Jagerflyet går i lufta\" href=\"https://www.dagbladet.no/video/jagerflyet-gar-i-lufta/qocxhxds\"><figure class=\"x__sc-1an7vu1-0 dsoriu\"><picture><img data-defer=\"view\" title=\"Image: Jagerflyet går i lufta\" alt=\"Image: Jagerflyet går i lufta\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/qocxhxds-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 glOqqI title dynamic-sizing\">Jagerflyet</span><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">går i lufta</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- 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 jIyTDK title dynamic-sizing\">- Stedatter</span><span class=\"x__pt8tzk-0 kYsbxS title dynamic-sizing\">nekter meg</span><span class=\"x__pt8tzk-0 dHKjeh title dynamic-sizing\">uskiftet bo</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>"]
Fritt
av Bjørnar Meisler