["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .dsbUeD.dsbUeD.dsbUeD.dsbUeD{height:0;padding-bottom:72.98%;}/*!sc*/ .ioDOlL.ioDOlL.ioDOlL.ioDOlL{height:0;padding-bottom:51.95%;}/*!sc*/ .gCXywp.gCXywp.gCXywp.gCXywp{height:0;padding-bottom:81.25%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .kgwdrg.kgwdrg.kgwdrg.kgwdrg{height:0;padding-bottom:71.14%;}/*!sc*/ .jrlTlV.jrlTlV.jrlTlV.jrlTlV{height:0;padding-bottom:102.98%;}/*!sc*/ .jBzAwk.jBzAwk.jBzAwk.jBzAwk{height:0;padding-bottom:56.08%;}/*!sc*/ .imatiz.imatiz.imatiz.imatiz{height:0;padding-bottom:77.11%;}/*!sc*/ .ebIGPt.ebIGPt.ebIGPt.ebIGPt{height:0;padding-bottom:52.81%;}/*!sc*/ .gbGggw.gbGggw.gbGggw.gbGggw{height:0;padding-bottom:66.25%;}/*!sc*/ .fDvauV.fDvauV.fDvauV.fDvauV{height:0;padding-bottom:86.8%;}/*!sc*/ .iYLNuD.iYLNuD.iYLNuD.iYLNuD{height:0;padding-bottom:56.7%;}/*!sc*/ .jDKzJI.jDKzJI.jDKzJI.jDKzJI{height:0;padding-bottom:74.37%;}/*!sc*/ .ipGkJP.ipGkJP.ipGkJP.ipGkJP{height:0;padding-bottom:71.39%;}/*!sc*/ .lmdjnV.lmdjnV.lmdjnV.lmdjnV{height:0;padding-bottom:55.93%;}/*!sc*/ .kuSVct.kuSVct.kuSVct.kuSVct{height:0;padding-bottom:60.62%;}/*!sc*/ .qZNfy.qZNfy.qZNfy.qZNfy{height:0;padding-bottom:81.84%;}/*!sc*/ .hZjwdV.hZjwdV.hZjwdV.hZjwdV{height:0;padding-bottom:99.75%;}/*!sc*/ .ldkMOS.ldkMOS.ldkMOS.ldkMOS{height:0;padding-bottom:51.54%;}/*!sc*/ .dhfOYC.dhfOYC.dhfOYC.dhfOYC{height:0;padding-bottom:84.32%;}/*!sc*/ .dugzBG.dugzBG.dugzBG.dugzBG{height:0;padding-bottom:71.56%;}/*!sc*/ .eAYXY.eAYXY.eAYXY.eAYXY{height:0;padding-bottom:58.75%;}/*!sc*/ .eLxrJd.eLxrJd.eLxrJd.eLxrJd{height:0;padding-bottom:65.36%;}/*!sc*/ .dMLSm.dMLSm.dMLSm.dMLSm{height:0;padding-bottom:52.57%;}/*!sc*/ .cbpmkX.cbpmkX.cbpmkX.cbpmkX{height:0;padding-bottom:121.64%;}/*!sc*/ .fdmiiT.fdmiiT.fdmiiT.fdmiiT{height:0;padding-bottom:67.41%;}/*!sc*/ .kiIgiH.kiIgiH.kiIgiH.kiIgiH{height:0;padding-bottom:78.43%;}/*!sc*/ .hTZISu.hTZISu.hTZISu.hTZISu{height:0;padding-bottom:63.91%;}/*!sc*/ .PdncX.PdncX.PdncX.PdncX{height:0;padding-bottom:72.63%;}/*!sc*/ .gYoHKl.gYoHKl.gYoHKl.gYoHKl{height:0;padding-bottom:55.31%;}/*!sc*/ .bbUhCo.bbUhCo.bbUhCo.bbUhCo{height:0;padding-bottom:71.54%;}/*!sc*/ .iPjCRj.iPjCRj.iPjCRj.iPjCRj{height:0;padding-bottom:68.75%;}/*!sc*/ .bnbYFz.bnbYFz.bnbYFz.bnbYFz{height:0;padding-bottom:91.04%;}/*!sc*/ .iZlNrJ.iZlNrJ.iZlNrJ.iZlNrJ{height:0;padding-bottom:58.12%;}/*!sc*/ .gzqAYE.gzqAYE.gzqAYE.gzqAYE{height:0;padding-bottom:66.87%;}/*!sc*/ .JtACp.JtACp.JtACp.JtACp{height:0;padding-bottom:50.3%;}/*!sc*/ .YTIkI.YTIkI.YTIkI.YTIkI{height:0;padding-bottom:55.47%;}/*!sc*/ .cEtGrV.cEtGrV.cEtGrV.cEtGrV{height:0;padding-bottom:79.37%;}/*!sc*/ .ioubUL.ioubUL.ioubUL.ioubUL{height:0;padding-bottom:80.59%;}/*!sc*/ .bEAsVD.bEAsVD.bEAsVD.bEAsVD{height:0;padding-bottom:61.25%;}/*!sc*/ .jUYClY.jUYClY.jUYClY.jUYClY{height:0;padding-bottom:54.06%;}/*!sc*/ .gwQmTe.gwQmTe.gwQmTe.gwQmTe{height:0;padding-bottom:65.31%;}/*!sc*/ data-styled.g380[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,fnQDHb,dsbUeD,ioDOlL,gCXywp,kviAry,kgwdrg,jrlTlV,jBzAwk,imatiz,ebIGPt,gbGggw,fDvauV,iYLNuD,jDKzJI,ipGkJP,lmdjnV,kuSVct,qZNfy,hZjwdV,ldkMOS,dhfOYC,dugzBG,eAYXY,eLxrJd,dMLSm,cbpmkX,fdmiiT,kiIgiH,hTZISu,PdncX,gYoHKl,bbUhCo,iPjCRj,bnbYFz,iZlNrJ,gzqAYE,JtACp,YTIkI,cEtGrV,ioubUL,bEAsVD,jUYClY,gwQmTe,\"}/*!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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .iAWFly.iAWFly.iAWFly.iAWFly{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iAWFly.iAWFly.iAWFly.iAWFly{font-size:2.2em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .dJenrE.dJenrE.dJenrE.dJenrE{font-size:6.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.dJenrE.dJenrE.dJenrE.dJenrE{font-size:2.3em!important;}}/*!sc*/ .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*/ .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*/ .bgmOop.bgmOop.bgmOop.bgmOop{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bgmOop.bgmOop.bgmOop.bgmOop{font-size:1.7em!important;}}/*!sc*/ .eLjpEa.eLjpEa.eLjpEa.eLjpEa{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.eLjpEa.eLjpEa.eLjpEa.eLjpEa{font-size:1.5em!important;}}/*!sc*/ .jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .blfWBn.blfWBn.blfWBn.blfWBn{font-size:9.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.blfWBn.blfWBn.blfWBn.blfWBn{font-size:3.2em!important;}}/*!sc*/ .cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:0.9em!important;}}/*!sc*/ .kxzaKl.kxzaKl.kxzaKl.kxzaKl{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.kxzaKl.kxzaKl.kxzaKl.kxzaKl{font-size:1em!important;}}/*!sc*/ .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*/ .bWSnVS.bWSnVS.bWSnVS.bWSnVS{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bWSnVS.bWSnVS.bWSnVS.bWSnVS{font-size:1.3em!important;}}/*!sc*/ .dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:1.9em!important;}}/*!sc*/ .kkHfrE.kkHfrE.kkHfrE.kkHfrE{font-size:8.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kkHfrE.kkHfrE.kkHfrE.kkHfrE{font-size:2.9em!important;}}/*!sc*/ .iEukpb.iEukpb.iEukpb.iEukpb{font-size:8.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iEukpb.iEukpb.iEukpb.iEukpb{font-size:3.1em!important;}}/*!sc*/ .dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:2.4em!important;}}/*!sc*/ .kAKGGI.kAKGGI.kAKGGI.kAKGGI{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kAKGGI.kAKGGI.kAKGGI.kAKGGI{font-size:2.5em!important;}}/*!sc*/ .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*/ .jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:6.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:2.4em!important;}}/*!sc*/ .egjpuh.egjpuh.egjpuh.egjpuh{font-size:8.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.egjpuh.egjpuh.egjpuh.egjpuh{font-size:2.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:0.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .kVJNPR.kVJNPR.kVJNPR.kVJNPR{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kVJNPR.kVJNPR.kVJNPR.kVJNPR{font-size:0.8em!important;}}/*!sc*/ .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*/ .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*/ .erpCho.erpCho.erpCho.erpCho{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.erpCho.erpCho.erpCho.erpCho{font-size:1em!important;}}/*!sc*/ .emaxbb.emaxbb.emaxbb.emaxbb{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.emaxbb.emaxbb.emaxbb.emaxbb{font-size:1.7em!important;}}/*!sc*/ .gPIxea.gPIxea.gPIxea.gPIxea{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gPIxea.gPIxea.gPIxea.gPIxea{font-size:1.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .tqGkg.tqGkg.tqGkg.tqGkg{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.tqGkg.tqGkg.tqGkg.tqGkg{font-size:1.9em!important;}}/*!sc*/ .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*/ .kVFQsM.kVFQsM.kVFQsM.kVFQsM{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kVFQsM.kVFQsM.kVFQsM.kVFQsM{font-size:0.7em!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*/ .jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:0.5em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .iKalhP.iKalhP.iKalhP.iKalhP{font-size:7.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iKalhP.iKalhP.iKalhP.iKalhP{font-size:2.7em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .diUuRk.diUuRk.diUuRk.diUuRk{font-size:1.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.diUuRk.diUuRk.diUuRk.diUuRk{font-size:0.4em!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*/ .ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:2.8em!important;}}/*!sc*/ .ChWbh.ChWbh.ChWbh.ChWbh{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.ChWbh.ChWbh.ChWbh.ChWbh{font-size:2em!important;}}/*!sc*/ .jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:2.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .emKkIi.emKkIi.emKkIi.emKkIi{font-size:10.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.emKkIi.emKkIi.emKkIi.emKkIi{font-size:3.7em!important;}}/*!sc*/ .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*/ .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*/ .cVHdDp.cVHdDp.cVHdDp.cVHdDp{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cVHdDp.cVHdDp.cVHdDp.cVHdDp{font-size:2.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*/ .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*/ .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*/ .kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:2.2em!important;}}/*!sc*/ .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*/ .eQgupK.eQgupK.eQgupK.eQgupK{font-size:8.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQgupK.eQgupK.eQgupK.eQgupK{font-size:3em!important;}}/*!sc*/ .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*/ .bHxiDg.bHxiDg.bHxiDg.bHxiDg{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bHxiDg.bHxiDg.bHxiDg.bHxiDg{font-size:1.6em!important;}}/*!sc*/ .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*/ .ioa-DgC.ioa-DgC.ioa-DgC.ioa-DgC{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.ioa-DgC.ioa-DgC.ioa-DgC.ioa-DgC{font-size:1.4em!important;}}/*!sc*/ .gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:1.8em!important;}}/*!sc*/ .ghdJaB.ghdJaB.ghdJaB.ghdJaB{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ghdJaB.ghdJaB.ghdJaB.ghdJaB{font-size:3em!important;}}/*!sc*/ .cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:0.8em!important;}}/*!sc*/ .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*/ .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*/ .bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:1.6em!important;}}/*!sc*/ .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*/ .ggUSon.ggUSon.ggUSon.ggUSon{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.ggUSon.ggUSon.ggUSon.ggUSon{font-size:0.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .kmxpNq.kmxpNq.kmxpNq.kmxpNq{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kmxpNq.kmxpNq.kmxpNq.kmxpNq{font-size:0.5em!important;}}/*!sc*/ data-styled.g381[id=\"x__pt8tzk-0\"]{content:\"fNDhDy,dfserP,ijicdz,iCwWtY,cKlSIC,fFAiTK,iAWFly,iXjdLY,hsPeia,bwzwBX,dbonoY,hejuQD,inhdgd,dJenrE,dDKeDQ,kwLuaB,bgmOop,eLjpEa,jGSTdz,eVVsXT,hbwikt,jCkLvS,blfWBn,cnaKkM,kxzaKl,jiGVVj,bWSnVS,dfgvpn,kkHfrE,iEukpb,dQSCBR,kAKGGI,jsjrYr,jfcAvK,egjpuh,bcCfuJ,frzFun,cFtCN,beDNpZ,hQxAYP,kUqUJf,lplqa-d,kMqJSM,kVJNPR,iNHyie,gApunH,erpCho,emaxbb,gPIxea,kNhGgX,epoJzD,jtCXvA,tqGkg,gLHLEv,kVFQsM,gjHDge,jRIgeY,jfvMWJ,kmfDed,hrVcDN,iKalhP,jdgMzU,ftetSQ,LzBnW,diUuRk,iFlEmK,ggbHpa,ChWbh,jJrnNf,ctWqNs,dWzMnA,jFsmoq,emKkIi,wpWLG,jdcGMN,cVHdDp,gVRWAB,eYoKgk,iYgBvA,kyzRFP,inoUtg,eQgupK,dPoeFo,bHxiDg,bwGQrt,ioa-DgC,gWsWwS,ghdJaB,cyVXzf,dyaAfc,jEhvtw,bkgkdp,kNAQKA,ggUSon,ldTjgH,kauVAS,bvXqXn,ghcHLl,fTAjeM,kmxpNq,\"}/*!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=\"Frokostknepet:- Kiloene raser!\" href=\"https://www.dagbladet.no/tema/frokostknepet-kiloene-raser/81456297\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><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=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\">Frokostknepet:-</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Kiloene raser!</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Johaug-bilder sjokkerer: - Vanvittig!\" href=\"https://www.dagbladet.no/video/johaug-bilder-forbauser/Lkhb3HZ4\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Johaug-bilder sjokkerer: - Vanvittig!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81513434.jpg?imageId=81513434&amp;x=0.000000&amp;y=3.811252&amp;cropw=100.000000&amp;croph=80.036298&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/06/06/fbc8e95e-4b48-4c05-85ec-e4209d56ad61/gif_johaug_4.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/06/06/fbc8e95e-4b48-4c05-85ec-e4209d56ad61/gif_johaug_4.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">Johaug-bilder</span><span class=\"x__pt8tzk-0 iCwWtY title dynamic-sizing\">sjokkerer:</span><span class=\"x__pt8tzk-0 cKlSIC title dynamic-sizing\">- Vanvittig!</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=\"Invitert med på trekant: - Vurderte det!\" href=\"https://www.dagbladet.no/kjendis/invitert-med-pa-trekant-vurderte-det/81513081\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Invitert med på trekant: - Vurderte det!\" alt=\"Image: Invitert med på trekant: - Vurderte det!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81513105&amp;panoy=22.857142857143&amp;panow=100&amp;panoh=33.809523809524&amp;panox=0&amp;heighty=0&amp;heightx=24.731182795699&amp;heightw=48.387096774194&amp;heighth=79.032258064516&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 fFAiTK title dynamic-sizing\">Invitert med</span><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">på trekant:</span><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">- Vurderte det!</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=\"- Ødelegger seg selv innenfra\" href=\"https://www.dagbladet.no/nyheter/odelegger-seg-selv-innenfra/81495929\"><figure class=\"x__sc-1an7vu1-0 dsbUeD\"><picture><img data-defer=\"view\" title=\"Image: - Ødelegger seg selv innenfra\" alt=\"Image: - Ødelegger seg selv innenfra\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81496153&amp;panoy=7.5376884422111&amp;panow=70.234113712375&amp;panoh=35.678391959799&amp;panox=11.371237458194&amp;heighty=5.6737588652482&amp;heightx=35.933806146572&amp;heightw=21.276595744681&amp;heighth=52.127659574468&amp;width=485&amp;height=354&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- Ødelegger seg</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">selv innenfra</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ringes ned: - Vil ikke!\" href=\"https://www.dagbladet.no/sport/ringes-ned-vil-ikke/81515137\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ringes ned: - Vil ikke!\" alt=\"Image: Ringes ned: - Vil ikke!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81515181&amp;panox=13.503649635036&amp;panow=76.642335766423&amp;panoh=32.56880733945&amp;panoy=12.844036697248&amp;heighty=6.5843621399177&amp;heightx=36.633663366337&amp;heightw=29.70297029703&amp;heighth=60.493827160494&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\">Ringes ned:</span><span class=\"x__pt8tzk-0 hejuQD title dynamic-sizing\">- Vil ikke!</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=\"Røper vane: - Grusomt\" href=\"https://www.dagbladet.no/kjendis/roper-vane-grusomt/81514291\"><figure class=\"x__sc-1an7vu1-0 ioDOlL\"><picture><img data-defer=\"view\" title=\"Image: Røper vane: - Grusomt\" alt=\"Image: Røper vane: - Grusomt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81514321&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=86.666666666667&amp;heighty=0&amp;heightw=100&amp;heighth=86.666666666667&amp;heightx=0&amp;width=485&amp;height=252&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\">Røper vane:</span><span class=\"x__pt8tzk-0 dJenrE title dynamic-sizing\">- Grusomt</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=\"«Bradley»-suksess: Nå får Ukraina hundrevis\" href=\"https://www.dagbladet.no/video/bradley-suksess-na-far-ukraina-hundrevis/ssvtWPE5\"><figure class=\"x__sc-1an7vu1-0 gCXywp\"><picture><img data-defer=\"view\" title=\"Image: «Bradley»-suksess: Nå får Ukraina hundrevis\" alt=\"Image: «Bradley»-suksess: Nå får Ukraina hundrevis\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/ssvtWPE5-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\">«Bradley»-suksess: Nå</span><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">får Ukraina hundrevis</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Jeg vil bare leve\" href=\"https://www.dagbladet.no/tema/jeanette-36-jeg-vil-bare-leve/81394933\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Jeg vil bare leve\" alt=\"Image: - Jeg vil bare leve\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81427402&amp;panow=100&amp;panoh=45.121951219512&amp;panoy=20.731707317073&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=20.098039215686&amp;heightw=46.078431372549&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 bgmOop title dynamic-sizing\">- Jeg vil</span><span class=\"x__pt8tzk-0 eLjpEa title dynamic-sizing\">bare leve</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=\"Deler kjærestens nakenbilde\" href=\"https://www.dagbladet.no/kjendis/deler-kjaerestens-nakenbilde/81507059\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Deler kjærestens nakenbilde\" alt=\"Image: Deler kjærestens nakenbilde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81507193&amp;panow=94.212523719165&amp;panoy=9.7240473061761&amp;panox=2.3719165085389&amp;panoh=73.455978975033&amp;heightx=28.362494699647&amp;heightw=31.802120141343&amp;heighth=71.707317073171&amp;heighty=18.760829268293&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">Deler kjærestens</span><span class=\"x__pt8tzk-0 eVVsXT title dynamic-sizing\">nakenbilde</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=\"- Kommer til å reise\" href=\"https://www.dagbladet.no/kjendis/kommer-til-a-reise/81504420\"><figure class=\"x__sc-1an7vu1-0 kgwdrg\"><picture><img data-defer=\"view\" title=\"Image: - Kommer til å reise\" alt=\"Image: - Kommer til å reise\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81504497&amp;panox=7.3684210526316&amp;panow=74.269005614035&amp;panoh=38.652481914894&amp;panoy=17.553191489362&amp;heighty=5.045871559633&amp;heightx=28.048780487805&amp;heightw=27.947154268293&amp;heighth=68.195718348624&amp;width=402&amp;height=286&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">- Kommer</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">til å reise</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=\"- Tyder på en erfaren gjeng\" href=\"https://www.dagbladet.no/nyheter/tyder-pa-en-erfaren-gjeng/81508451\"><figure class=\"x__sc-1an7vu1-0 jrlTlV\"><picture><img data-defer=\"view\" title=\"Image: - Tyder på en erfaren gjeng\" alt=\"Image: - Tyder på en erfaren gjeng\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81508548&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=414&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- Tyder på en</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">erfaren gjeng</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=\"Her slutter alle spor\" href=\"https://www.dagbladet.no/nyheter/her-slutter-alle-spor/81517559\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Her slutter alle spor\" alt=\"Image: Her slutter alle spor\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81517568&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=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\">Her slutter</span><span class=\"x__pt8tzk-0 blfWBn title dynamic-sizing\">alle spor</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 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=\"Rovdyret lusker - så skjer dette\" href=\"https://www.dagbladet.no/video/gar-gjennom-isen/8ImgiVSG\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Rovdyret lusker - så skjer dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81517756.jpg?imageId=81517756&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/12/22/d6cf94f8-8a49-45fa-979f-9fa690306c03/gif_-_ulvedrama.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/12/22/d6cf94f8-8a49-45fa-979f-9fa690306c03/gif_-_ulvedrama.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cnaKkM title dynamic-sizing\">Rovdyret lusker</span><span class=\"x__pt8tzk-0 kxzaKl title dynamic-sizing\">- så skjer 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=\"- Det krasjet litt for meg\" href=\"https://www.dagbladet.no/kjendis/det-krasjet-litt-for-meg/81326073\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Det krasjet litt for meg\" alt=\"Image: - Det krasjet litt for meg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81326967&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=320&amp;height=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\">- Det krasjet</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">litt for meg</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=\"Bløff avslørt av turist\" href=\"https://www.dagbladet.no/nyheter/bloff-avslort-av-turist/81512229\"><figure class=\"x__sc-1an7vu1-0 jBzAwk\"><picture><img data-defer=\"view\" title=\"Image: Bløff avslørt av turist\" alt=\"Image: Bløff avslørt av turist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81512233&amp;panoy=1.4184397163121&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;heighty=0&amp;heightx=48.868778280543&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=272&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">Bløff avslørt</span><span class=\"x__pt8tzk-0 kkHfrE title dynamic-sizing\">av turist</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=\"- Norge står alene\" href=\"https://www.dagbladet.no/nyheter/norge-star-alene/81463209\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Norge står alene\" alt=\"Image: - Norge står alene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463265&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iEukpb title dynamic-sizing\">- Norge</span><span class=\"x__pt8tzk-0 dQSCBR title dynamic-sizing\">står alene</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=\"- Skikkelig dunking\" href=\"https://www.dagbladet.no/nyheter/skikkelig-dunking/81515739\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Skikkelig dunking\" alt=\"Image: - Skikkelig dunking\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81516762&amp;panox=36.790923824959&amp;panoy=54.938271604938&amp;panow=34.305780551053&amp;panoh=22.427983333333&amp;heightx=41.694915254237&amp;heightw=15.536723050847&amp;heighth=47.649572435897&amp;heighty=39.102564102564&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 kAKGGI title dynamic-sizing\">- Skikkelig</span><span class=\"x__pt8tzk-0 jsjrYr title dynamic-sizing\">dunking</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=\"- Han er lei seg\" href=\"https://www.dagbladet.no/nyheter/han-er-lei-seg/81508271\"><figure class=\"x__sc-1an7vu1-0 imatiz\"><picture><img data-defer=\"view\" title=\"Image: - Han er lei seg\" alt=\"Image: - Han er lei seg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81508275&amp;panoy=15.753424657534&amp;panox=0&amp;panow=100&amp;panoh=48.630136986301&amp;heightx=12.796208530806&amp;heightw=42.654028436019&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=310&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfcAvK title dynamic-sizing\">- Han er</span><span class=\"x__pt8tzk-0 egjpuh title dynamic-sizing\">lei seg</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=\"Får nok av Skistad: - Frekt! \" href=\"https://www.dagbladet.no/video/far-nok-av-skistad-frekt-/zU4rZbra\"><figure class=\"x__sc-1an7vu1-0 ebIGPt\"><picture><img data-defer=\"view\" title=\"Image: Får nok av Skistad: - Frekt! \" alt=\"Image: Får nok av Skistad: - Frekt! \" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/zU4rZbra-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 bcCfuJ title dynamic-sizing\">Får nok av</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">Skistad: - Frekt! </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=\"Kåring: Norges største badminton-talenter\" href=\"https://www.dagbladet.no/sport/karing-norges-storste-badminton-talenter/81447668\"><figure class=\"x__sc-1an7vu1-0 gbGggw\"><picture><img data-defer=\"view\" title=\"Image: Kåring: Norges største badminton-talenter\" alt=\"Image: Kåring: Norges største badminton-talenter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81447769&amp;panoy=15.384615384615&amp;panow=99.893674641148&amp;panoh=49.494951048951&amp;panox=0&amp;heighty=0&amp;heightx=31.132075471698&amp;heightw=42.348009433962&amp;heighth=99.847794520548&amp;width=320&amp;height=212&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Kåring: Norges største</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">badminton-talenter</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=\"Gålmmå iesjsårmmima: Aktelasj måråstime\" href=\"https://www.dagbladet.no/annonsorinnhold/v/dagbladet/helsedirektoratet/jeg-holdt-pa-a-miste-det/11141364/lulesamisk/11141411/\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/09/14/hdirlogo1.png\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Gålmmå iesjsårmmima: Aktelasj måråstime\" alt=\"Image: Gålmmå iesjsårmmima: Aktelasj måråstime\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81441025.jpg?imageId=81441025&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 beDNpZ title dynamic-sizing\">Gålmmå iesjsårmmima:</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Aktelasj måråstime</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=\"Lønna: - Skammer meg\" href=\"https://www.dagbladet.no/sport/lonna-skammer-meg/81501174\"><figure class=\"x__sc-1an7vu1-0 fDvauV\"><picture><img data-defer=\"view\" title=\"Image: Lønna: - Skammer meg\" alt=\"Image: Lønna: - Skammer meg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81501386&amp;panox=38.952164009112&amp;panow=47.835990888383&amp;panoh=23.509933774834&amp;panoy=16.887417218543&amp;heighty=2.8368794326241&amp;heightx=53.284671532847&amp;heightw=21.897810218978&amp;heighth=52.127659574468&amp;width=485&amp;height=421&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">Lønna: - Skammer meg</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=\"- Jævligste i mitt liv\" href=\"https://www.dagbladet.no/sport/jaevligste-i-mitt-liv/81517393\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Jævligste i mitt liv\" alt=\"Image: - Jævligste i mitt liv\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81517397&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">- Jævligste</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">i mitt liv</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=\"Dommer slår alarm: - Urimelig strengt\" href=\"https://www.dagbladet.no/nyheter/dommer-slar-alarm-urimelig-strengt/81493395\"><figure class=\"x__sc-1an7vu1-0 iYLNuD\"><picture><img data-defer=\"view\" title=\"Image: Dommer slår alarm: - Urimelig strengt\" alt=\"Image: Dommer slår alarm: - Urimelig strengt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81510658&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=275&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 lplqa-d title dynamic-sizing\">Dommer slår alarm:</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">- Urimelig strengt</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=\"- Åpnet magen med brekkjern\" href=\"https://www.dagbladet.no/nyheter/apnet-magen-med-brekkjern/81483056\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Åpnet magen med brekkjern\" alt=\"Image: - Åpnet magen med brekkjern\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81510373&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=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\">- Åpnet magen</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">med brekkjern</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=\"ADHD-medisiner: Ekspertens advarsel \" href=\"https://www.dagbladet.no/tema/adhd-medisiner-ekspertens-advarsel/81481454\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: ADHD-medisiner: Ekspertens advarsel \" alt=\"Image: ADHD-medisiner: Ekspertens advarsel \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81492478&amp;panoh=32.132132432432&amp;panoy=27.927927927928&amp;panox=37.437437237237&amp;panow=62.562562762763&amp;heighth=79.099099459459&amp;heighty=10.810810810811&amp;heightx=52.329749103943&amp;heightw=32.019116129032&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">ADHD-medisiner:</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Ekspertens advarsel </span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Knekker sammen totalt\" href=\"https://www.dagbladet.no/video/her-bryter-superstjerna-sammen/w0wfDTbD\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Knekker sammen totalt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81516021.jpg?imageId=81516021&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/06/07/e7bc1574-eeb1-4bee-9889-1253985ab1f2/gif_-_friends.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/06/07/e7bc1574-eeb1-4bee-9889-1253985ab1f2/gif_-_friends.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 gApunH title dynamic-sizing\">Knekker</span><span class=\"x__pt8tzk-0 erpCho title dynamic-sizing\">sammen totalt</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=\"E-poster funnet: - Forbundet med drapet\" href=\"https://www.dagbladet.no/nyheter/e-poster-funnet-forbundet-med-drapet/81509639\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: E-poster funnet: - Forbundet med drapet\" alt=\"Image: E-poster funnet: - Forbundet med drapet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81511312&amp;panoy=50.177935943061&amp;panox=0&amp;panow=100&amp;panoh=25.622775800712&amp;heightw=62.937062937063&amp;heighth=76.5625&amp;heighty=23.4375&amp;heightx=21.678321678322&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 emaxbb title dynamic-sizing\">E-poster funnet:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">- Forbundet med drapet</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=\"Her bryter hun kongelig etikette\" href=\"https://www.dagbladet.no/kjendis/her-bryter-hun-kongelig-etikette/81512373\"><figure class=\"x__sc-1an7vu1-0 jDKzJI\"><picture><img data-defer=\"view\" title=\"Image: Her bryter hun kongelig etikette\" alt=\"Image: Her bryter hun kongelig etikette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81512377&amp;panoy=14.285714285714&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=41.176470588235&amp;width=402&amp;height=299&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\">Her bryter hun</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">kongelig etikette</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=\"Setter fyr på ryktene\" href=\"https://www.dagbladet.no/kjendis/setter-fyr-pa-ryktene/81506664\"><figure class=\"x__sc-1an7vu1-0 ipGkJP\"><picture><img data-defer=\"view\" title=\"Image: Setter fyr på ryktene\" alt=\"Image: Setter fyr på ryktene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81506464&amp;panoy=8.8888888888889&amp;panox=0&amp;panow=100&amp;panoh=22.539682539683&amp;heightx=30.555555555556&amp;heightw=41.666666666667&amp;heighth=44.954128440367&amp;heighty=1.2232415902141&amp;width=402&amp;height=287&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">Setter fyr</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">på ryktene</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=\"Sjokkerte - får norsk hyllest\" href=\"https://www.dagbladet.no/sport/sendte-sjokkbolger-kan-bli-superduell/81504481\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Sjokkerte - får norsk hyllest\" alt=\"Image: Sjokkerte - får norsk hyllest\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81509168&amp;panoy=19.565217391304&amp;panox=0.1073536231884&amp;panow=100.10735362319&amp;panoh=50.885668115942&amp;heightw=40.927624770642&amp;heighth=100.15325655172&amp;heighty=0.15325655172413&amp;heightx=34.862385321101&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">Sjokkerte - får</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">norsk hyllest</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=\"Ber Tyskland forberede seg på krig\" href=\"https://www.dagbladet.no/video/-ma-vaere-klare-til-krig-innen-2029/6y4Fyslo\"><figure class=\"x__sc-1an7vu1-0 lmdjnV moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Ber Tyskland forberede seg på krig\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81508511.jpg?imageId=81508511&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=179\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/06/05/a38a5e65-62dc-4df2-9030-eb1696938e7a/gif_tysker.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/06/05/a38a5e65-62dc-4df2-9030-eb1696938e7a/gif_tysker.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">Ber Tyskland</span><span class=\"x__pt8tzk-0 kVFQsM title dynamic-sizing\">forberede seg på krig</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=\"Søvnapné: Advarer mot CAP-maske\" href=\"https://www.dagbladet.no/tema/sovnapne-fellene-styr-unna-disse/81445873\"><figure class=\"x__sc-1an7vu1-0 kuSVct\"><picture><img data-defer=\"view\" title=\"Image: Søvnapné: Advarer mot CAP-maske\" alt=\"Image: Søvnapné: Advarer mot CAP-maske\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81447357&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=320&amp;height=194&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Søvnapné: Advarer</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">mot CAP-maske</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=\"– Psykiske skïemtjelasse lea dïeve tabuvijstie\" href=\"https://www.dagbladet.no/annonsorinnhold/v/dagbladet/helsedirektoratet/jeg-holdt-pa-a-miste-det/11141364/sorsamisk/11141412/\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/09/14/hdirlogo1.png\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: – Psykiske skïemtjelasse lea dïeve tabuvijstie\" alt=\"Image: – Psykiske skïemtjelasse lea dïeve tabuvijstie\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81441025.jpg?imageId=81441025&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 jRIgeY title dynamic-sizing\">– Psykiske skïemtjelasse</span><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">lea dïeve tabuvijstie</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=\"Campingsjef sier fra: - Stemmer ikke\" href=\"https://www.dagbladet.no/nyheter/campingsjef-sier-fra-stemmer-ikke/81498886\"><figure class=\"x__sc-1an7vu1-0 qZNfy\"><picture><img data-defer=\"view\" title=\"Image: Campingsjef sier fra: - Stemmer ikke\" alt=\"Image: Campingsjef sier fra: - Stemmer ikke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81500197&amp;panow=56.720430107527&amp;panoh=25.992779783393&amp;panoy=34.657039711191&amp;panox=3.7634408602151&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=329&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Campingsjef sier</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">fra: - Stemmer ikke</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=\"Frustrert\" href=\"https://www.dagbladet.no/sport/frustrert/81510785\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Frustrert\" alt=\"Image: Frustrert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81510791&amp;panoy=43.125&amp;panox=0&amp;panow=86.3425925&amp;panoh=43.88888875&amp;heightw=40.927624770642&amp;heighth=100.15325655172&amp;heighty=0.15325655172413&amp;heightx=10.550458715596&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 kmfDed title dynamic-sizing\">Frustrert</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=\"- Hvorfor skulle jeg si nei?\" href=\"https://www.dagbladet.no/sport/hvorfor-skulle-jeg-si-nei/81491959\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Hvorfor skulle jeg si nei?\" alt=\"Image: - Hvorfor skulle jeg si nei?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81370079&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">- Hvorfor skulle</span><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">jeg si nei?</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Raser mot «hyttefolket»: - Drit og faenskap\" href=\"https://www.dagbladet.no/nyheter/raser-mot-hyttefolket-drit-og-faenskap/81502279\"><figure class=\"x__sc-1an7vu1-0 hZjwdV\"><picture><img data-defer=\"view\" title=\"Image: Raser mot «hyttefolket»: - Drit og faenskap\" alt=\"Image: Raser mot «hyttefolket»: - Drit og faenskap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81502541&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=401&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 cFtCN title dynamic-sizing\">Raser mot «hyttefolket»:</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">- Drit og faenskap</span></h3></header></a></article></div><div class=\"row xrow flex-initial fullwidth fullscreen-z-index\"><div id=\"apos-smartbanner2\" class=\"adunit-wrapper columns small-12 medium-12 large-12 track-element  \" data-from=\"xavier\"><div id=\"ad-smartbanner2\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600],[980,300],[970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;smartbanner2&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Går ikke bra akkurat nå\" href=\"https://www.dagbladet.no/kjendis/gar-ikke-bra-akkurat-na/81511228\"><figure class=\"x__sc-1an7vu1-0 ldkMOS\"><picture><img data-defer=\"view\" title=\"Image: - Går ikke bra akkurat nå\" alt=\"Image: - Går ikke bra akkurat nå\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81511231&amp;panow=99.842766981132&amp;panoy=34.497816593886&amp;panox=0&amp;panoh=15.866084279476&amp;heightx=30.555555555556&amp;heightw=42.438271296296&amp;heighth=31.902718025751&amp;heighty=22.961373390558&amp;width=485&amp;height=250&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfcAvK title dynamic-sizing\">- Går ikke</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">bra akkurat nå</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=\"- Strevde med et mørke\" href=\"https://www.dagbladet.no/kjendis/strevde-med-et-morke/81514132\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Strevde med et mørke\" alt=\"Image: - Strevde med et mørke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81515176&amp;panoy=17.391304347826&amp;panow=100&amp;panoh=51.449275362319&amp;panox=0&amp;heighty=0&amp;heightx=36.254980079681&amp;heightw=35.856573705179&amp;heighth=88.55421686747&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eVVsXT title dynamic-sizing\">- Strevde</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">med et mørke</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=\"- Fantastisk\" href=\"https://www.dagbladet.no/sport/fantastisk/81517786\"><figure class=\"x__sc-1an7vu1-0 dhfOYC\"><picture><img data-defer=\"view\" title=\"Image: - Fantastisk\" alt=\"Image: - Fantastisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81517957&amp;panoh=50.729927007299&amp;panoy=0&amp;panox=0&amp;panow=100.24390243902&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=339&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">- Fantastisk</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=\"Overlevde katastrofe - ødelagt av turist\" href=\"https://www.dagbladet.no/nyheter/overlevde-katastrofe-odelagt-av-turist/81503254\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Overlevde katastrofe - ødelagt av turist\" alt=\"Image: Overlevde katastrofe - ødelagt av turist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81503405&amp;panoy=32.978723404255&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=25.768321276596&amp;heighty=26.767676767677&amp;heightw=30.864197306397&amp;heighth=37.542087373737&amp;heightx=33.333333333333&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 kMqJSM title dynamic-sizing\">Overlevde katastrofe</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">- ødelagt av turist</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=\"ADHD-medisin:Urovekkende funn\" href=\"https://www.dagbladet.no/tema/adhd-medisinurovekkende-funn/81349829\"><figure class=\"x__sc-1an7vu1-0 dugzBG\"><picture><img data-defer=\"view\" title=\"Image: ADHD-medisin:Urovekkende funn\" alt=\"Image: ADHD-medisin:Urovekkende funn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81350241&amp;panow=66.025641025641&amp;panoh=35.897435897436&amp;panoy=44.845360824742&amp;panox=0&amp;heighty=0&amp;heightx=12.227074235808&amp;heightw=38.427947598253&amp;heighth=100&amp;width=320&amp;height=229&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 diUuRk title dynamic-sizing\">ADHD-medisin:Urovekkende funn</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-black\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slåss for livet\" href=\"https://www.dagbladet.no/video/filmer-voldsom-kamp/EKtOb2vR\"><figure class=\"x__sc-1an7vu1-0 eAYXY moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Slåss for livet\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81518381.jpg?imageId=81518381&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=188\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/06/07/db4d70df-d1a8-4fab-982a-0c0159055ce1/gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/06/07/db4d70df-d1a8-4fab-982a-0c0159055ce1/gif_1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Slåss for livet</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=\"Ødela vennskapet med sex\" href=\"https://www.dagbladet.no/kjendis/odela-vennskapet-med-sex/81508428\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ødela vennskapet med sex\" alt=\"Image: Ødela vennskapet med sex\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=78913221&amp;panoy=11.428571428571&amp;panox=0&amp;panow=100&amp;panoh=33.809523809524&amp;heighty=0&amp;heightw=39.301310043668&amp;heighth=64.192139737991&amp;heightx=29.694323144105&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">Ødela vennskapet</span><span class=\"x__pt8tzk-0 ggbHpa title dynamic-sizing\">med sex</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=\"Russiske sjokktall: - Ikke tillitsverdige\" href=\"https://www.dagbladet.no/nyheter/russiske-sjokktall-ikke-tillitsverdige/81507035\"><figure class=\"x__sc-1an7vu1-0 eLxrJd\"><picture><img data-defer=\"view\" title=\"Image: Russiske sjokktall: - Ikke tillitsverdige\" alt=\"Image: Russiske sjokktall: - Ikke tillitsverdige\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81509218&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=317&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Russiske sjokktall:</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">- Ikke tillitsverdige</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=\"Slik utspilte kaoset seg\" href=\"https://www.dagbladet.no/sport/slik-utspilte-kaoset-seg/81517200\"><figure class=\"x__sc-1an7vu1-0 dMLSm\"><picture><img data-defer=\"view\" title=\"Image: Slik utspilte kaoset seg\" alt=\"Image: Slik utspilte kaoset seg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81517385&amp;panow=100&amp;panoh=51.063829787234&amp;panoy=9.2198581560284&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=255&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ChWbh title dynamic-sizing\">Slik utspilte</span><span class=\"x__pt8tzk-0 jJrnNf title dynamic-sizing\">kaoset seg</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 ny kjæreste\" href=\"https://www.dagbladet.no/kjendis/bekrefter-ny-kjaereste/81512326\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter ny kjæreste\" alt=\"Image: Bekrefter ny kjæreste\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81510813&amp;panoh=60.169491525424&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=55.232558139535&amp;heightw=26.647286627907&amp;heighth=76.632302061856&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 ctWqNs title dynamic-sizing\">Bekrefter</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">ny kjæreste</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=\"Folk reagerer på dette\" href=\"https://www.dagbladet.no/video/folk-reagerer-pa-dette/P01Izyce\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Folk reagerer på dette\" alt=\"Image: Folk reagerer på dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/P01Izyce-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Folk reagerer</span><span class=\"x__pt8tzk-0 jFsmoq title dynamic-sizing\">på 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=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Quiz uke 23: Simens ti kjappe!\" href=\"https://www.dagbladet.no/nyheter/quiz-uke-23-simens-ti-kjappe/81514548\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Quiz uke 23: Simens ti kjappe!\" alt=\"Image: Quiz uke 23: Simens ti kjappe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81056783&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Quiz uke 23:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Simens ti kjappe!</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-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=\"Skadd i el-sykkelulykke\" href=\"https://www.dagbladet.no/kjendis/skadd-i-el-sykkelulykke/81506591\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Skadd i el-sykkelulykke\" alt=\"Image: Skadd i el-sykkelulykke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81506595&amp;panoy=22.58064516129&amp;panow=60.518731988473&amp;panoh=16.359447004608&amp;panox=17.291066282421&amp;heighty=15.833333333333&amp;heightx=45.478036175711&amp;heightw=23.255813953488&amp;heighth=30.625&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 emKkIi title dynamic-sizing\">Skadd i</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">el-sykkelulykke</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=\"Protest-drama: Avvist\" href=\"https://www.dagbladet.no/sport/protest-drama-avvist/81512883\"><figure class=\"x__sc-1an7vu1-0 cbpmkX\"><picture><img data-defer=\"view\" title=\"Image: Protest-drama: Avvist\" alt=\"Image: Protest-drama: Avvist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81514368&amp;panoy=17.142857142857&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightx=24.886877828054&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=489&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Protest-drama: Avvist</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=\"Sex-sjokk: - Midt i rushtida\" href=\"https://www.dagbladet.no/nyheter/sex-sjokk-midt-i-rushtida/81505773\"><figure class=\"x__sc-1an7vu1-0 fdmiiT\"><picture><img data-defer=\"view\" title=\"Image: Sex-sjokk: - Midt i rushtida\" alt=\"Image: Sex-sjokk: - Midt i rushtida\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81506026&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=271&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\">Sex-sjokk:</span><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">- Midt i rushtida</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=\"Truer motstandere:- Episk maktmisbruk\" href=\"https://www.dagbladet.no/nyheter/truer-motstandere-episk-maktmisbruk/81506209\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Truer motstandere:- Episk maktmisbruk\" alt=\"Image: Truer motstandere:- Episk maktmisbruk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81479325&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=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 kNhGgX title dynamic-sizing\">Truer motstandere:-</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Episk maktmisbruk</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=\"- Tror russeren er inni\" href=\"https://www.dagbladet.no/video/absurd-russisk-taktikk-hva-er-det/6MsSlDQf\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: - Tror russeren er inni\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81506282.jpg?imageId=81506282&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/06/04/2ada9a52-4e06-4167-b96b-785f549f4abe/badekargif2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/06/04/2ada9a52-4e06-4167-b96b-785f549f4abe/badekargif2.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\">- Tror russeren</span><span class=\"x__pt8tzk-0 cVHdDp title dynamic-sizing\">er inni</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=\"Lavt stoffskifte-studie: - Bedre enn Levaxin\" href=\"https://www.dagbladet.no/tema/lavt-stoffskifte-studie-bedre-enn-levaxin/81319976\"><figure class=\"x__sc-1an7vu1-0 kiIgiH\"><picture><img data-defer=\"view\" title=\"Image: Lavt stoffskifte-studie: - Bedre enn Levaxin\" alt=\"Image: Lavt stoffskifte-studie: - Bedre enn Levaxin\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81350582&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=251&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\">Lavt stoffskifte-studie:</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">- Bedre enn Levaxin</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=\"Nå er hun gift\" href=\"https://www.dagbladet.no/kjendis/na-er-hun-gift/81516260\"><figure class=\"x__sc-1an7vu1-0 hTZISu\"><picture><img data-defer=\"view\" title=\"Image: Nå er hun gift\" alt=\"Image: Nå er hun gift\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81516496&amp;panoy=9.1715976331361&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=21.499013609467&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=310&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">Nå er hun gift</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=\"Melding etter bisarr hendelse\" href=\"https://www.dagbladet.no/sport/melding-etter-bisarr-hendelse/81511617\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Melding etter bisarr hendelse\" alt=\"Image: Melding etter bisarr hendelse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81511621&amp;panox=0.1073536231884&amp;panoy=23.008849557522&amp;panow=100.10735362319&amp;panoh=62.143559292035&amp;heightx=35.094339622642&amp;heightw=33.668763018868&amp;heighth=100.15325655172&amp;heighty=0.15325655172413&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\">Melding etter</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">bisarr hendelse</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=\"Politimann utsatt for vold\" href=\"https://www.dagbladet.no/nyheter/politimann-utsatt-for-vold/81518339\"><figure class=\"x__sc-1an7vu1-0 PdncX\"><picture><img data-defer=\"view\" title=\"Image: Politimann utsatt for vold\" alt=\"Image: Politimann utsatt for vold\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81518347&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=292&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">Politimann</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">utsatt for vold</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=\"Raknet over natta: - Ikke mer å gi\" href=\"https://www.dagbladet.no/kjendis/raknet-over-natta-ikke-mer-a-gi/81516785\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Raknet over natta: - Ikke mer å gi\" alt=\"Image: Raknet over natta: - Ikke mer å gi\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81516820&amp;panoy=17.117117117117&amp;panox=0&amp;panow=100&amp;panoh=31.981981981982&amp;heighty=0&amp;heightx=15.827338129496&amp;heightw=64.748201438849&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 eYoKgk title dynamic-sizing\">Raknet over natta:</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">- Ikke mer å gi</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=\"Hudleger hyller nytt klø-middel: Gratis\" href=\"https://www.dagbladet.no/tema/hudleger-hyller-nytt-klo-middel-gratis/81460635\"><figure class=\"x__sc-1an7vu1-0 gYoHKl\"><picture><img data-defer=\"view\" title=\"Image: Hudleger hyller nytt klø-middel: Gratis\" alt=\"Image: Hudleger hyller nytt klø-middel: Gratis\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81464074&amp;panow=100&amp;panoh=100&amp;panox=0&amp;panoy=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=177&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\">Hudleger hyller nytt</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">klø-middel: Gratis</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 gYoHKl\"><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=\"Første dødsfall med H5N2\" href=\"https://www.dagbladet.no/nyheter/forste-dodsfall-med-h5n2/81506958\"><figure class=\"x__sc-1an7vu1-0 bbUhCo\"><picture><img data-defer=\"view\" title=\"Image: Første dødsfall med H5N2\" alt=\"Image: Første dødsfall med H5N2\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81506990&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=347&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\">Første dødsfall</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">med H5N2</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=\"Har fått beskjed\" href=\"https://www.dagbladet.no/sport/har-fatt-beskjed/81511456\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Har fått beskjed\" alt=\"Image: Har fått beskjed\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81511539&amp;panox=0.1073536231884&amp;panow=100.10735362319&amp;panoh=50.885668115942&amp;panoy=20.289855072464&amp;heighth=100.15325655172&amp;heighty=0.15325655172413&amp;heightx=26.605504587156&amp;heightw=40.927624770642&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Har fått</span><span class=\"x__pt8tzk-0 eQgupK title dynamic-sizing\">beskjed</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russland: Flere skadd\" href=\"https://www.dagbladet.no/video/russland-flere-skadd/KBCP3BpB\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russland: Flere skadd\" alt=\"Image: Russland: Flere skadd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/KBCP3BpB-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Russland:</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Flere skadd</span></h3></header></a></article><article class=\"preview columns small-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 iPjCRj\"><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=220&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-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=\"Alvorlig syk: Rørende melding\" href=\"https://www.dagbladet.no/sport/alvorlig-syk-rorende-melding/81501412\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Alvorlig syk: Rørende melding\" alt=\"Image: Alvorlig syk: Rørende melding\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81501672&amp;panox=13.440860215054&amp;panow=56.720430107527&amp;panoh=29.268292682927&amp;panoy=12.19512195122&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">Alvorlig syk:</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">Rørende 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=\"Snefrid og Erik om sorgen: - Forferdelig\" href=\"https://www.dagbladet.no/kjendis/snefrid-og-erik-om-sorgen-forferdelig/81506766\"><figure class=\"x__sc-1an7vu1-0 bnbYFz\"><picture><img data-defer=\"view\" title=\"Image: Snefrid og Erik om sorgen: - Forferdelig\" alt=\"Image: Snefrid og Erik om sorgen: - Forferdelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81508016&amp;panow=99.842766981132&amp;panoh=61.064425210084&amp;panoy=0&amp;panox=0&amp;heighty=10.106382978723&amp;heightx=41.317365269461&amp;heightw=27.445109580838&amp;heighth=79.078013829787&amp;width=402&amp;height=366&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Snefrid og Erik om</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">sorgen: - Forferdelig</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=\"Inngrodd negl: Grepet som fungerer\" href=\"https://www.dagbladet.no/tema/inngrodd-negl-grepet-som-fungerer/81433091\"><figure class=\"x__sc-1an7vu1-0 iZlNrJ\"><picture><img data-defer=\"view\" title=\"Image: Inngrodd negl: Grepet som fungerer\" alt=\"Image: Inngrodd negl: Grepet som fungerer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81445339&amp;panow=99.859251231527&amp;panoh=50.899466666667&amp;panoy=5.1851851851852&amp;panox=0.14074876847291&amp;heightw=33.351646153846&amp;heighty=0&amp;heightx=46.153846153846&amp;heighth=81.337734104046&amp;width=320&amp;height=186&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\">Inngrodd negl:</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Grepet som fungerer</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=\"Raser mot TV 2\" href=\"https://www.dagbladet.no/video/raser-mot-tv-2/2xzETyUN\"><figure class=\"x__sc-1an7vu1-0 iZlNrJ\"><picture><img data-defer=\"view\" title=\"Image: Raser mot TV 2\" alt=\"Image: Raser mot TV 2\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/2xzETyUN-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Raser mot TV 2</span></h3></header></a></article></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=\"Bildene «hele» Norge så\" href=\"https://www.dagbladet.no/video/bildene-hele-norge-sa/eMUs8yPN\"><figure class=\"x__sc-1an7vu1-0 gzqAYE\"><picture><img data-defer=\"view\" title=\"Image: Bildene «hele» Norge så\" alt=\"Image: Bildene «hele» Norge så\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/eMUs8yPN-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Bildene «hele»</span><span class=\"x__pt8tzk-0 bHxiDg title dynamic-sizing\">Norge så</span></h3></header></a></article><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=\"Sandras (33) oppskrift: Rik på aksjer\" href=\"https://www.dagbladet.no/tema/sandras-33-oppskrift-rik-pa-aksjer/81463375\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Sandras (33) oppskrift: Rik på aksjer\" alt=\"Image: Sandras (33) oppskrift: Rik på aksjer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463423&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Sandras (33)</span><span class=\"x__pt8tzk-0 ioa-DgC title dynamic-sizing\">oppskrift:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Rik på aksjer</span></h3></header></a></article><div id=\"apos-medium-rectangle7\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle7\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ber om hjelp fra Oslo\" href=\"https://www.dagbladet.no/nyheter/ber-om-hjelp-fra-oslo/81498443\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ber om hjelp fra Oslo\" alt=\"Image: Ber om hjelp fra Oslo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81498493&amp;panoy=6.6350710900474&amp;panox=13.178294573643&amp;panow=81.550387596899&amp;panoh=34.312796208531&amp;heighty=0.27210884353742&amp;heightx=26.256983240223&amp;heightw=50.502793296089&amp;heighth=100.27210884354&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 gWsWwS title dynamic-sizing\">Ber om hjelp</span><span class=\"x__pt8tzk-0 ghdJaB title dynamic-sizing\">fra Oslo</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=\"- Ikke vært like flink\" href=\"https://www.dagbladet.no/kjendis/ikke-vaert-like-flink/81492721\"><figure class=\"x__sc-1an7vu1-0 JtACp\"><picture><img data-defer=\"view\" title=\"Image: - Ikke vært like flink\" alt=\"Image: - Ikke vært like flink\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81492134&amp;panoy=21.12676056338&amp;panox=0&amp;panow=100&amp;panoh=50&amp;heightx=34.200743494424&amp;heightw=33.457249070632&amp;heighth=81.21546961326&amp;heighty=5.524861878453&amp;width=485&amp;height=244&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\">- Ikke vært</span><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">like flink</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=\"Supergrepene mot neglesopp: Billig og effektivt!\" href=\"https://www.dagbladet.no/tema/supergrepene-mot-neglesopp-billig-og-effektivt/81328715\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Supergrepene mot neglesopp: Billig og effektivt!\" alt=\"Image: Supergrepene mot neglesopp: Billig og effektivt!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335659&amp;panoy=15.328467153285&amp;panox=0&amp;panow=100&amp;panoh=51.094890510949&amp;heightw=40.93023255814&amp;heighth=100&amp;heightx=3.7209302325581&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Supergrepene mot</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">neglesopp: Billig</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">og effektivt!</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=\"TV-bildene skaper latter\" href=\"https://www.dagbladet.no/video/i-tarer-etter-bragd/IFjc7gOG\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: TV-bildene skaper latter\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81514452.jpg?imageId=81514452&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/06/07/8da6af01-9624-415b-b761-18d110d57ed3/gif_.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/06/07/8da6af01-9624-415b-b761-18d110d57ed3/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 cKlSIC title dynamic-sizing\">TV-bildene</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">skaper latter</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=\"Pepret med spørsmål\" href=\"https://www.dagbladet.no/sport/pepret-med-sporsmal/81513426\"><figure class=\"x__sc-1an7vu1-0 YTIkI\"><picture><img data-defer=\"view\" title=\"Image: Pepret med spørsmål\" alt=\"Image: Pepret med spørsmål\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81516079&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=6.4285714285714&amp;heighty=0&amp;heightx=37.727272727273&amp;heightw=40.909090909091&amp;heighth=100&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 bkgkdp title dynamic-sizing\">Pepret med</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">spørsmål</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=\"Gult farevarsel om lyn: - Hold deg innendørs\" href=\"https://www.dagbladet.no/nyheter/gult-farevarsel-om-lyn-hold-deg-innendors/81511501\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Gult farevarsel om lyn: - Hold deg innendørs\" alt=\"Image: Gult farevarsel om lyn: - Hold deg innendørs\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81509793&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">Gult farevarsel om lyn:</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">- Hold deg innendørs</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=\"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-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=\"Studie: Tre setninger avslører narsissisten\" href=\"https://www.dagbladet.no/tema/studie-tre-setninger-avslorer-narsissisten/81361047\"><figure class=\"x__sc-1an7vu1-0 cEtGrV\"><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=254&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\">Studie: Tre setninger</span><span class=\"x__pt8tzk-0 ggUSon title dynamic-sizing\">avslører narsissisten</span></h3></header></a></article><div id=\"apos-medium-rectangle8\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Det rareste jeg har sett\" href=\"https://www.dagbladet.no/sport/det-rareste-jeg-har-sett/81517570\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Det rareste jeg har sett\" alt=\"Image: - Det rareste jeg har sett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81517627&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=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 iAWFly title dynamic-sizing\">- Det rareste</span><span class=\"x__pt8tzk-0 ldTjgH title dynamic-sizing\">jeg har sett</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=\"Over 700 tilfeller i mai\" href=\"https://www.dagbladet.no/nyheter/over-700-tilfeller-i-mai/81515886\"><figure class=\"x__sc-1an7vu1-0 ioubUL\"><picture><img data-defer=\"view\" title=\"Image: Over 700 tilfeller i mai\" alt=\"Image: Over 700 tilfeller i mai\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81515895&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=324&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">Over 700</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">tilfeller i mai</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=\"Sonjas IBS-grep: - Helt frisk!\" href=\"https://www.dagbladet.no/tema/sonjas-ibs-grep-helt-frisk/81497731\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Sonjas IBS-grep: - Helt frisk!\" alt=\"Image: Sonjas IBS-grep: - Helt frisk!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81516581&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">Sonjas IBS-grep:</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">- Helt frisk!</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=\"Pinlig berørt: - Ikke gøy!\" href=\"https://www.dagbladet.no/video/snikfilmes-ikke-goy/nRMgrHli\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Pinlig berørt: - Ikke gøy!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81515882.jpg?imageId=81515882&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/06/07/95f69db7-da65-442f-a394-8643ffe5a476/gif_groevdal_.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/06/07/95f69db7-da65-442f-a394-8643ffe5a476/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 gLHLEv title dynamic-sizing\">Pinlig berørt:</span><span class=\"x__pt8tzk-0 bvXqXn title dynamic-sizing\">- Ikke gøy!</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=\"- Vil føre til utryddelse\" href=\"https://www.dagbladet.no/video/-vil-fore-til-utryddelse/MBbs28T2\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Vil føre til utryddelse\" alt=\"Image: - Vil føre til utryddelse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/MBbs28T2-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 hrVcDN title dynamic-sizing\">- Vil føre</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">til utryddelse</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=\"IBD kobles til alvorlig sykdom \" href=\"https://www.dagbladet.no/tema/ibd-kobles-til-alvorlig-sykdom/81455742\"><figure class=\"x__sc-1an7vu1-0 bEAsVD\"><picture><img data-defer=\"view\" title=\"Image: IBD kobles til alvorlig sykdom \" alt=\"Image: IBD kobles til alvorlig sykdom \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81457742&amp;panox=0&amp;panow=99.893674641148&amp;panoh=60.493829059829&amp;panoy=22.222222222222&amp;heighty=0.22371409395974&amp;heightx=33.986818181818&amp;heightw=34.722221969697&amp;heighth=99.77628590604&amp;width=320&amp;height=196&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ghcHLl title dynamic-sizing\">IBD kobles til</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">alvorlig sykdom </span></h3></header></a></article><div id=\"apos-medium-rectangle9\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard11\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Plantar fascitt-grep: 80 prosent blir bra \" href=\"https://www.dagbladet.no/tema/plantar-fascitt-grep-80-prosent-blir-bra/81456026\"><figure class=\"x__sc-1an7vu1-0 jUYClY\"><picture><img data-defer=\"view\" title=\"Image: Plantar fascitt-grep: 80 prosent blir bra \" alt=\"Image: Plantar fascitt-grep: 80 prosent blir bra \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81466013&amp;panox=0.10683749999999&amp;panow=100.1068375&amp;panoh=34.241452884615&amp;panoy=21.338509615385&amp;heightw=61.532566896552&amp;heighth=100.15325655172&amp;heighty=0.15325655172413&amp;heightx=23.448275862069&amp;width=320&amp;height=173&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Plantar fascitt-grep:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">80 prosent blir bra </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 jUYClY\"><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=\"Norske bilder forbløffer\" href=\"https://www.dagbladet.no/video/norske-bilder-forbloffer/FCI8ULMh\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Norske bilder forbløffer\" alt=\"Image: Norske bilder forbløffer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/FCI8ULMh-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\">Norske bilder</span><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">forbløffer</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=\"Kjærlighetssvindel: Deler de skjulte tegnene\" href=\"https://www.dagbladet.no/tema/ble-kjaerlighetssvindletdeler-de-skjulte-tegnene/81407038\"><figure class=\"x__sc-1an7vu1-0 iPjCRj\"><picture><img data-defer=\"view\" title=\"Image: Kjærlighetssvindel: Deler de skjulte tegnene\" alt=\"Image: Kjærlighetssvindel: Deler de skjulte tegnene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81408021&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0.22831095890411&amp;heightw=44.891122613065&amp;heighth=100.2283109589&amp;heightx=33.165829145729&amp;width=320&amp;height=220&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\">Kjærlighetssvindel:</span><span class=\"x__pt8tzk-0 kmxpNq title dynamic-sizing\">Deler de skjulte tegnene</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=\"Måper: - Tidenes beste straffe\" href=\"https://www.dagbladet.no/video/maper-tidenes-beste-straffe/rqmD1FyO\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Måper: - Tidenes beste straffe\" alt=\"Image: Måper: - Tidenes beste straffe\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/rqmD1FyO-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Måper: - Tidenes</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">beste straffe</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=\"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 fjJyvE\"><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=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\">Ferie-fellene:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Pengene du kan få</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=\"Kvinne tok selfie - døde\" href=\"https://www.dagbladet.no/video/kvinne-tok-selfie-dode/50NNPCL6\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Kvinne tok selfie - døde\" alt=\"Image: Kvinne tok selfie - døde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/50NNPCL6-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\">Kvinne tok</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">selfie - døde</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=\"Gjeldsproblemer: Pengehjelpen fra Nav\" href=\"https://www.dagbladet.no/tema/gjeldsproblemer-pengehjelpen-fra-nav/81342721\"><figure class=\"x__sc-1an7vu1-0 gwQmTe\"><picture><img data-defer=\"view\" title=\"Image: Gjeldsproblemer: Pengehjelpen fra Nav\" alt=\"Image: Gjeldsproblemer: Pengehjelpen fra Nav\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81347559&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=320&amp;height=209&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Gjeldsproblemer:</span><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Pengehjelpen fra Nav</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