["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .jyPive.jyPive.jyPive.jyPive{height:0;padding-bottom:50.51%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .ldkMOS.ldkMOS.ldkMOS.ldkMOS{height:0;padding-bottom:51.54%;}/*!sc*/ .bbtmgY.bbtmgY.bbtmgY.bbtmgY{height:0;padding-bottom:82.81%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .hPMFKU.hPMFKU.hPMFKU.hPMFKU{height:0;padding-bottom:86.81%;}/*!sc*/ .ipGkJP.ipGkJP.ipGkJP.ipGkJP{height:0;padding-bottom:71.39%;}/*!sc*/ .eWEEkc.eWEEkc.eWEEkc.eWEEkc{height:0;padding-bottom:51.34%;}/*!sc*/ .hWvEne.hWvEne.hWvEne.hWvEne{height:0;padding-bottom:76.11%;}/*!sc*/ .hjCnKb.hjCnKb.hjCnKb.hjCnKb{height:0;padding-bottom:60%;}/*!sc*/ .jDKzJI.jDKzJI.jDKzJI.jDKzJI{height:0;padding-bottom:74.37%;}/*!sc*/ .fOjzly.fOjzly.fOjzly.fOjzly{height:0;padding-bottom:65.97%;}/*!sc*/ .cQSpuk.cQSpuk.cQSpuk.cQSpuk{height:0;padding-bottom:52.37%;}/*!sc*/ .dAKxVo.dAKxVo.dAKxVo.dAKxVo{height:0;padding-bottom:57.67%;}/*!sc*/ .eMwOLg.eMwOLg.eMwOLg.eMwOLg{height:0;padding-bottom:79.85%;}/*!sc*/ .bZIcOd.bZIcOd.bZIcOd.bZIcOd{height:0;padding-bottom:59.06%;}/*!sc*/ .cBQWRq.cBQWRq.cBQWRq.cBQWRq{height:0;padding-bottom:70.31%;}/*!sc*/ .iNTUgw.iNTUgw.iNTUgw.iNTUgw{height:0;padding-bottom:74.62%;}/*!sc*/ .hhSwZo.hhSwZo.hhSwZo.hhSwZo{height:0;padding-bottom:98.75%;}/*!sc*/ .kdZLYR.kdZLYR.kdZLYR.kdZLYR{height:0;padding-bottom:77.93%;}/*!sc*/ .bptmYL.bptmYL.bptmYL.bptmYL{height:0;padding-bottom:76.36%;}/*!sc*/ .hygKBp.hygKBp.hygKBp.hygKBp{height:0;padding-bottom:63.43%;}/*!sc*/ .dPhbyL.dPhbyL.dPhbyL.dPhbyL{height:0;padding-bottom:93.6%;}/*!sc*/ .fYvkjy.fYvkjy.fYvkjy.fYvkjy{height:0;padding-bottom:67.62%;}/*!sc*/ .dystQj.dystQj.dystQj.dystQj{height:0;padding-bottom:67.81%;}/*!sc*/ .cCuzIK.cCuzIK.cCuzIK.cCuzIK{height:0;padding-bottom:108.95%;}/*!sc*/ .gSabaN.gSabaN.gSabaN.gSabaN{height:0;padding-bottom:111.69%;}/*!sc*/ .bqoCfD.bqoCfD.bqoCfD.bqoCfD{height:0;padding-bottom:59.37%;}/*!sc*/ .dsbUeD.dsbUeD.dsbUeD.dsbUeD{height:0;padding-bottom:72.98%;}/*!sc*/ .hWgrNA.hWgrNA.hWgrNA.hWgrNA{height:0;padding-bottom:114.92%;}/*!sc*/ .edtodV.edtodV.edtodV.edtodV{height:0;padding-bottom:62.06%;}/*!sc*/ .iGqPLB.iGqPLB.iGqPLB.iGqPLB{height:0;padding-bottom:80%;}/*!sc*/ .ifbRza.ifbRza.ifbRza.ifbRza{height:0;padding-bottom:86.56%;}/*!sc*/ .jJDuNs.jJDuNs.jJDuNs.jJDuNs{height:0;padding-bottom:57.5%;}/*!sc*/ .kbQZSd.kbQZSd.kbQZSd.kbQZSd{height:0;padding-bottom:71.95%;}/*!sc*/ .bcRKOI.bcRKOI.bcRKOI.bcRKOI{height:0;padding-bottom:96.51%;}/*!sc*/ .gkSegO.gkSegO.gkSegO.gkSegO{height:0;padding-bottom:65.93%;}/*!sc*/ .jbIdpI.jbIdpI.jbIdpI.jbIdpI{height:0;padding-bottom:68.9%;}/*!sc*/ .kAAGbU.kAAGbU.kAAGbU.kAAGbU{height:0;padding-bottom:57.18%;}/*!sc*/ .ibyVuT.ibyVuT.ibyVuT.ibyVuT{height:0;padding-bottom:56.25%;}/*!sc*/ .iYOkok.iYOkok.iYOkok.iYOkok{height:0;padding-bottom:51.87%;}/*!sc*/ .jOMhbl.jOMhbl.jOMhbl.jOMhbl{height:0;padding-bottom:76.25%;}/*!sc*/ data-styled.g380[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,jyPive,fnQDHb,ldkMOS,bbtmgY,kviAry,hPMFKU,ipGkJP,eWEEkc,hWvEne,hjCnKb,jDKzJI,fOjzly,cQSpuk,dAKxVo,eMwOLg,bZIcOd,cBQWRq,iNTUgw,hhSwZo,kdZLYR,bptmYL,hygKBp,dPhbyL,fYvkjy,dystQj,cCuzIK,gSabaN,bqoCfD,dsbUeD,hWgrNA,edtodV,iGqPLB,ifbRza,jJDuNs,kbQZSd,bcRKOI,gkSegO,jbIdpI,kAAGbU,ibyVuT,iYOkok,jOMhbl,\"}/*!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*/ .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*/ .jfhrCI.jfhrCI.jfhrCI.jfhrCI{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfhrCI.jfhrCI.jfhrCI.jfhrCI{font-size:1.2em!important;}}/*!sc*/ .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*/ .ddbCJZ.ddbCJZ.ddbCJZ.ddbCJZ{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ddbCJZ.ddbCJZ.ddbCJZ.ddbCJZ{font-size:2.1em!important;}}/*!sc*/ .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*/ .ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:2.9em!important;}}/*!sc*/ .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*/ .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*/ .ffsMfG.ffsMfG.ffsMfG.ffsMfG{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.ffsMfG.ffsMfG.ffsMfG.ffsMfG{font-size:2.4em!important;}}/*!sc*/ .iLHueX.iLHueX.iLHueX.iLHueX{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iLHueX.iLHueX.iLHueX.iLHueX{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .cZmotM.cZmotM.cZmotM.cZmotM{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cZmotM.cZmotM.cZmotM.cZmotM{font-size:0.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .FSsOO.FSsOO.FSsOO.FSsOO{font-size:9.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.FSsOO.FSsOO.FSsOO.FSsOO{font-size:3.4em!important;}}/*!sc*/ .eEpMqg.eEpMqg.eEpMqg.eEpMqg{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.eEpMqg.eEpMqg.eEpMqg.eEpMqg{font-size:2.3em!important;}}/*!sc*/ .gnnEgw.gnnEgw.gnnEgw.gnnEgw{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gnnEgw.gnnEgw.gnnEgw.gnnEgw{font-size:1.4em!important;}}/*!sc*/ .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*/ .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*/ .dLwqhJ.dLwqhJ.dLwqhJ.dLwqhJ{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dLwqhJ.dLwqhJ.dLwqhJ.dLwqhJ{font-size:1.4em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .gALHSm.gALHSm.gALHSm.gALHSm{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.gALHSm.gALHSm.gALHSm.gALHSm{font-size:1.9em!important;}}/*!sc*/ .kyvmra.kyvmra.kyvmra.kyvmra{font-size:8.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kyvmra.kyvmra.kyvmra.kyvmra{font-size:3em!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*/ .gyIQtO.gyIQtO.gyIQtO.gyIQtO{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gyIQtO.gyIQtO.gyIQtO.gyIQtO{font-size:2.7em!important;}}/*!sc*/ .bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:2em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .inksEV.inksEV.inksEV.inksEV{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.inksEV.inksEV.inksEV.inksEV{font-size:1.3em!important;}}/*!sc*/ .cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:1.7em!important;}}/*!sc*/ .hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:1.8em!important;}}/*!sc*/ .Uccen.Uccen.Uccen.Uccen{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.Uccen.Uccen.Uccen.Uccen{font-size:1.7em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .kpDSmG.kpDSmG.kpDSmG.kpDSmG{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kpDSmG.kpDSmG.kpDSmG.kpDSmG{font-size:2em!important;}}/*!sc*/ .eyIQTS.eyIQTS.eyIQTS.eyIQTS{font-size:13.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.eyIQTS.eyIQTS.eyIQTS.eyIQTS{font-size:4.7em!important;}}/*!sc*/ .jPbWVE.jPbWVE.jPbWVE.jPbWVE{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jPbWVE.jPbWVE.jPbWVE.jPbWVE{font-size:1.8em!important;}}/*!sc*/ .criDNb.criDNb.criDNb.criDNb{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.criDNb.criDNb.criDNb.criDNb{font-size:2em!important;}}/*!sc*/ .jdcGMN.jdcGMN.jdcGMN.jdcGMN{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jdcGMN.jdcGMN.jdcGMN.jdcGMN{font-size:1.4em!important;}}/*!sc*/ .kLBvft.kLBvft.kLBvft.kLBvft{font-size:7.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kLBvft.kLBvft.kLBvft.kLBvft{font-size:2.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .gNDiBf.gNDiBf.gNDiBf.gNDiBf{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gNDiBf.gNDiBf.gNDiBf.gNDiBf{font-size:2.3em!important;}}/*!sc*/ .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*/ .eDnlaH.eDnlaH.eDnlaH.eDnlaH{font-size:10.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.eDnlaH.eDnlaH.eDnlaH.eDnlaH{font-size:3.7em!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*/ .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*/ .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*/ .dXa-DVQ.dXa-DVQ.dXa-DVQ.dXa-DVQ{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.dXa-DVQ.dXa-DVQ.dXa-DVQ.dXa-DVQ{font-size:1.1em!important;}}/*!sc*/ .jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .itkiNJ.itkiNJ.itkiNJ.itkiNJ{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.itkiNJ.itkiNJ.itkiNJ.itkiNJ{font-size:0.9em!important;}}/*!sc*/ .fnuVOB.fnuVOB.fnuVOB.fnuVOB{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.fnuVOB.fnuVOB.fnuVOB.fnuVOB{font-size:0.8em!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*/ .XaoDC.XaoDC.XaoDC.XaoDC{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.XaoDC.XaoDC.XaoDC.XaoDC{font-size:2.1em!important;}}/*!sc*/ .cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:7em!important;}/*!sc*/ @media only screen and (max-width:640px){.cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:2.4em!important;}}/*!sc*/ .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*/ .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*/ .iITVJY.iITVJY.iITVJY.iITVJY{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iITVJY.iITVJY.iITVJY.iITVJY{font-size:1em!important;}}/*!sc*/ .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*/ .BsLeO.BsLeO.BsLeO.BsLeO{font-size:2.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.BsLeO.BsLeO.BsLeO.BsLeO{font-size:0.8em!important;}}/*!sc*/ .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*/ .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:\"jiGVVj,bWSnVS,cKlSIC,jfhrCI,iKalhP,ddbCJZ,fFAiTK,ePuSwO,jfcAvK,eYoKgk,ffsMfG,iLHueX,dDKeDQ,frzFun,cZmotM,bwGQrt,eLjpEa,dfgvpn,FSsOO,eEpMqg,gnnEgw,jEhvtw,dyaAfc,dLwqhJ,LzBnW,kNhGgX,gPIxea,gALHSm,kyvmra,ctWqNs,gyIQtO,bxtuZJ,epoJzD,kxzaKl,wpWLG,dPoeFo,ggUSon,dfserP,kVJNPR,bwzwBX,hrVcDN,blfWBn,hQxAYP,hbwikt,jtCXvA,cVHdDp,iYgBvA,inksEV,cnjOqe,hPDIHE,Uccen,erpCho,cFtCN,cyVXzf,kpDSmG,eyIQTS,jPbWVE,criDNb,jdcGMN,kLBvft,iAWFly,inoUtg,inhdgd,kauVAS,jfvMWJ,diUuRk,dQSCBR,gNDiBf,gVRWAB,eDnlaH,kUqUJf,jdgMzU,bHxiDg,dXa-DVQ,jGSTdz,tqGkg,iEukpb,bvXqXn,ftetSQ,kMqJSM,beDNpZ,gLHLEv,itkiNJ,fnuVOB,bkgkdp,XaoDC,cUXKOF,hsPeia,iFlEmK,iITVJY,lplqa-d,BsLeO,jRIgeY,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=\"- 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><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=\"Plutselig er den om bord\" href=\"https://www.dagbladet.no/video/skrekkopplevelse-skal-jeg-skyte/jADrikJm\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Plutselig er den om bord\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81460047.jpg?imageId=81460047&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/2021/08/27/5a5a5010-b1ab-4d09-9653-ab2cd636b44d/gif_isbjoern.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2021/08/27/5a5a5010-b1ab-4d09-9653-ab2cd636b44d/gif_isbjoern.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\">Plutselig er</span><span class=\"x__pt8tzk-0 jfhrCI title dynamic-sizing\">den om bord</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=\"Ny video vist i retten\" href=\"https://www.dagbladet.no/nyheter/ny-video-vist-i-retten/81464952\"><figure class=\"x__sc-1an7vu1-0 jyPive\"><picture><img data-defer=\"view\" title=\"Image: Ny video vist i retten\" alt=\"Image: Ny video vist i retten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81464965&amp;panox=0&amp;panow=100&amp;panoh=60.169491525424&amp;panoy=0&amp;heightx=36.781609195402&amp;heighty=0&amp;heightw=34.48275862069&amp;heighth=100&amp;width=485&amp;height=245&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">Ny video</span><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">vist i retten</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ny melding: Dropper\" href=\"https://www.dagbladet.no/sport/ny-melding-dropper/81464971\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ny melding: Dropper\" alt=\"Image: Ny melding: Dropper\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81464977&amp;panoh=50.714285714286&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=31.818181818182&amp;heightw=40.909090909091&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 fFAiTK title dynamic-sizing\">Ny melding:</span><span class=\"x__pt8tzk-0 ePuSwO title dynamic-sizing\">Dropper</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=\"Hintet om invasjonsplaner\" href=\"https://www.dagbladet.no/nyheter/hintet-om-invasjonsplaner/81455631\"><figure class=\"x__sc-1an7vu1-0 ldkMOS\"><picture><img data-defer=\"view\" title=\"Image: Hintet om invasjonsplaner\" alt=\"Image: Hintet om invasjonsplaner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81455681&amp;panow=99.842766981132&amp;panoh=51.173708450704&amp;panoy=9.8591549295775&amp;panox=0.15723301886793&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=250&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfcAvK title dynamic-sizing\">Hintet om</span><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">invasjonsplaner</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sverre M. Fjelstad er død\" href=\"https://www.dagbladet.no/nyheter/sverre-m-fjelstad-er-dod/81464482\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Sverre M. Fjelstad er død\" alt=\"Image: Sverre M. Fjelstad er død\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81464489&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=60.683760683761&amp;heighty=0&amp;heightw=26.239067055394&amp;heighth=76.5625&amp;heightx=27.405247813411&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 ffsMfG title dynamic-sizing\">Sverre M.</span><span class=\"x__pt8tzk-0 iLHueX title dynamic-sizing\">Fjelstad er død</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ukrainsk missilangrep: - Over 100 drept\" href=\"https://www.dagbladet.no/video/ukrainsk-missilangrep-over-100-drept/wWGsrDHF\"><figure class=\"x__sc-1an7vu1-0 bbtmgY\"><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><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=\"Nye sjokkfunn: Kobler ADHD til lidelse\" href=\"https://www.dagbladet.no/tema/nye-sjokkfunn-kobler-adhd-til-lidelse/81253162\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Nye sjokkfunn: Kobler ADHD til lidelse\" alt=\"Image: Nye sjokkfunn: Kobler ADHD til lidelse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81253720&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">Nye sjokkfunn:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Kobler ADHD</span><span class=\"x__pt8tzk-0 eLjpEa title dynamic-sizing\">til lidelse</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=\"Selger svindyr leilighet\" href=\"https://www.dagbladet.no/kjendis/selger-svindyr-leilighet/81460748\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Selger svindyr leilighet\" alt=\"Image: Selger svindyr leilighet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81460817&amp;panoy=5.6016597510373&amp;panox=18.59649122807&amp;panow=74.269005614035&amp;panoh=15.076071784232&amp;heighty=0&amp;heightx=28.494623655914&amp;heightw=49.283153763441&amp;heighth=47.195766984127&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">Selger svindyr</span><span class=\"x__pt8tzk-0 FSsOO title dynamic-sizing\">leilighet</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nedtur - ingen ville by\" href=\"https://www.dagbladet.no/kjendis/nedtur-ingen-ville-by/81459822\"><figure class=\"x__sc-1an7vu1-0 hPMFKU\"><picture><img data-defer=\"view\" title=\"Image: Nedtur - ingen ville by\" alt=\"Image: Nedtur - ingen ville by\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81459830&amp;panow=62.072336070381&amp;panox=12.903225806452&amp;panoh=16.220237946429&amp;panoy=19.419642857143&amp;heightx=30.25641025641&amp;heighty=16.441005802708&amp;heightw=23.504273333333&amp;heighth=28.75564139265&amp;width=402&amp;height=349&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eEpMqg title dynamic-sizing\">Nedtur -</span><span class=\"x__pt8tzk-0 gnnEgw title dynamic-sizing\">ingen ville by</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=\"Vannet strømmer inn Unity Arena\" href=\"https://www.dagbladet.no/nyheter/vannet-strommer-inn-unity-arena/81464309\"><figure class=\"x__sc-1an7vu1-0 ipGkJP\"><picture><img data-defer=\"view\" title=\"Image: Vannet strømmer inn Unity Arena\" alt=\"Image: Vannet strømmer inn Unity Arena\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81464351&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=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 jEhvtw title dynamic-sizing\">Vannet strømmer</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">inn Unity Arena</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=\"Etter Israels dødsangrep: - Dypt urovekkende\" href=\"https://www.dagbladet.no/nyheter/etter-israels-dodsangrep-dypt-urovekkende/81464781\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Etter Israels dødsangrep: - Dypt urovekkende\" alt=\"Image: Etter Israels dødsangrep: - Dypt urovekkende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81464805&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=6.4285714285714&amp;heightw=40.909090909091&amp;heighty=0&amp;heightx=59.090909090909&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 jEhvtw title dynamic-sizing\">Etter Israels dødsangrep:</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">- Dypt urovekkende</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russland: Flere skadd\" href=\"https://www.dagbladet.no/video/russland-flere-skadd/KBCP3BpB\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russland: Flere skadd\" alt=\"Image: Russland: Flere skadd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/KBCP3BpB-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Russland:</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Flere skadd</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"IBS kobles til alvorlig sykdom \" href=\"https://www.dagbladet.no/tema/ibs-kobles-til-alvorlig-sykdom/81455742\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: IBS kobles til alvorlig sykdom \" alt=\"Image: IBS 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=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">IBS kobles til</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">alvorlig sykdom </span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 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=\"- Det sprakk for ham\" href=\"https://www.dagbladet.no/nyheter/det-sprakk-for-ham/81459118\"><figure class=\"x__sc-1an7vu1-0 eWEEkc\"><picture><img data-defer=\"view\" title=\"Image: - Det sprakk for ham\" alt=\"Image: - Det sprakk for ham\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81459376&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=249&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gALHSm title dynamic-sizing\">- Det sprakk</span><span class=\"x__pt8tzk-0 kyvmra title dynamic-sizing\">for ham</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 kjæreste\" href=\"https://www.dagbladet.no/kjendis/bekrefter-kjaereste/81463421\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter kjæreste\" alt=\"Image: Bekrefter kjæreste\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463444&amp;panoh=22.851152830189&amp;panow=99.842766981132&amp;panoy=4.4025157232704&amp;panox=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">Bekrefter</span><span class=\"x__pt8tzk-0 gyIQtO title dynamic-sizing\">kjæreste</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=\"OL-vinner tatt for doping\" href=\"https://www.dagbladet.no/sport/ol-vinner-tatt-for-doping/81463849\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: OL-vinner tatt for doping\" alt=\"Image: OL-vinner tatt for doping\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463853&amp;panoy=10.714285714286&amp;panow=100&amp;panoh=51.428571428571&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">OL-vinner tatt</span><span class=\"x__pt8tzk-0 gyIQtO title dynamic-sizing\">for doping</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=\"Våpen-ordkrigen fortsetter: - Leker med ilden\" href=\"https://www.dagbladet.no/nyheter/vapen-ordkrigen-fortsetter-leker-med-ilden/81463673\"><figure class=\"x__sc-1an7vu1-0 hWvEne\"><picture><img data-defer=\"view\" title=\"Image: Våpen-ordkrigen fortsetter: - Leker med ilden\" alt=\"Image: Våpen-ordkrigen fortsetter: - Leker med ilden\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463704&amp;panoy=10.169491525424&amp;panox=2.6315789473684&amp;panow=78.947368421053&amp;panoh=40.112994350282&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=306&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Våpen-ordkrigen</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">fortsetter:</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">- Leker med ilden</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Redningen sett av millioner\" href=\"https://www.dagbladet.no/video/redningen-sett-av-millioner/N7n4ufvR\"><figure class=\"x__sc-1an7vu1-0 hjCnKb moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Redningen sett av millioner\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/73901771.jpg?imageId=73901771&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=192\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2021/06/14/e55d88ad-00b7-4908-b03e-949615c097aa/loeve_sliter_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2021/06/14/e55d88ad-00b7-4908-b03e-949615c097aa/loeve_sliter_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 kxzaKl title dynamic-sizing\">Redningen sett</span><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">av millioner</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 jDKzJI\"><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=238&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 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><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=\"Vant etter fire ekstraomganger!\" href=\"https://norsk-tipping.pxf.io/c/2839344/1983267/13114?sharedid=Dagbladet&amp;subid1=Direktehenvisning%20-%20forh%C3%A5ndssak&amp;subid2=DB&amp;subid3=contentoddsenH%C3%A5ndball&amp;adid=Direktehenvisning%20-%20forh%C3%A5ndssak&amp;adname=DB&amp;adtype=contentoddsenH%C3%A5ndball&amp;u=https%3A%2F%2Fwww.norsk-tipping.no%2Fartikler%2Fkolstad-elverum-den-avgjorende-kampen-utsolgt-pa-et-kvarter%3Fm%3Ddagbladet_dagbladet_ekomm_annet_db__ekomm-null%26utm_source%3Ddagbladet%26utm_medium%3Dekomm%26utm_campaign%3Dnull%26utm_content%3Dannet_db&amp;allerID=202405289\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2018/11/20/norsk%20tipping%20logo%202.png\" data-defer=\"view\" alt=\"Norsk logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Vant etter fire ekstraomganger!\" alt=\"Image: Vant etter fire ekstraomganger!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81460325.jpg?imageId=81460325&amp;x=0.000000&amp;y=14.701378&amp;cropw=100.000000&amp;croph=67.534456&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 dfserP title dynamic-sizing\">Vant etter fire</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">ekstraomganger!</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span>Norsk</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=\"Avslørt: - Ja, vi er sammen\" href=\"https://www.dagbladet.no/sport/avslort-ja-vi-er-sammen/81460071\"><figure class=\"x__sc-1an7vu1-0 fOjzly\"><picture><img data-defer=\"view\" title=\"Image: Avslørt: - Ja, vi er sammen\" alt=\"Image: Avslørt: - Ja, vi er sammen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81460081&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=320&amp;compression=70\" 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\">Avslørt: - Ja,</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">vi er sammen</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=\"I sorg:- Utrolig trist\" href=\"https://www.dagbladet.no/kjendis/i-sorg-utrolig-trist/81457134\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: I sorg:- Utrolig trist\" alt=\"Image: I sorg:- Utrolig trist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81457259&amp;panoy=34.316353887399&amp;panox=0&amp;panow=100&amp;panoh=19.034852546917&amp;heightx=17.931034482759&amp;heightw=62.068965517241&amp;heighth=56.976744186047&amp;heighty=17.1875&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 blfWBn title dynamic-sizing\">I sorg:-</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">Utrolig trist</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=\"Ny beskjed etter sjokket\" href=\"https://www.dagbladet.no/sport/ny-beskjed/81455076\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ny beskjed etter sjokket\" alt=\"Image: Ny beskjed etter sjokket\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81455106&amp;panox=0&amp;panow=100&amp;panoh=45.806451612903&amp;panoy=0&amp;heighty=0&amp;heightx=23.618090452261&amp;heightw=45.226130653266&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 hbwikt title dynamic-sizing\">Ny beskjed</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">etter sjokket</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russiske ballonger på grensa\" href=\"https://www.dagbladet.no/nyheter/russiske-ballonger-pa-grensa/81459863\"><figure class=\"x__sc-1an7vu1-0 cQSpuk\"><picture><img data-defer=\"view\" title=\"Image: Russiske ballonger på grensa\" alt=\"Image: Russiske ballonger på grensa\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81460135&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=254&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfhrCI title dynamic-sizing\">Russiske ballonger</span><span class=\"x__pt8tzk-0 cVHdDp title dynamic-sizing\">på grensa</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=\"Hanne (30) kuttet dette: Kvitt eksem\" href=\"https://www.dagbladet.no/tema/hanne-30-kuttet-dette-kvitt-eksem/81246958\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Hanne (30) kuttet dette: Kvitt eksem\" alt=\"Image: Hanne (30) kuttet dette: Kvitt eksem\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81246979&amp;panox=26.190476190476&amp;panoy=6.5934065934066&amp;panow=45.454545454545&amp;panoh=78.021978021978&amp;heightw=12.278308321965&amp;heighth=100&amp;heighty=0&amp;heightx=33.682830930537&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\">Hanne (30) kuttet</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">dette: Kvitt eksem</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=\"- Ble sendt i 52 land\" href=\"https://www.dagbladet.no/video/-kunne-aldri-gjort-det-i-dag/rbT73Oi8\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: - Ble sendt i 52 land\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81452408.jpg?imageId=81452408&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/24/285c48d6-bd21-467f-bb6a-47e5730584f8/gifs_ep_14_my_ass_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/24/285c48d6-bd21-467f-bb6a-47e5730584f8/gifs_ep_14_my_ass_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 inksEV title dynamic-sizing\">- Ble sendt</span><span class=\"x__pt8tzk-0 cnjOqe title dynamic-sizing\">i 52 land</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=\"Ordkrig: Nekter\" href=\"https://www.dagbladet.no/nyheter/ordkrig-nekter/81461740\"><figure class=\"x__sc-1an7vu1-0 dAKxVo\"><picture><img data-defer=\"view\" title=\"Image: Ordkrig: Nekter\" alt=\"Image: Ordkrig: Nekter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81462518&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=567&amp;height=327&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">Ordkrig: Nekter</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=\"Stjerne legger opp\" href=\"https://www.dagbladet.no/sport/stjerne-legger-opp/81464014\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Stjerne legger opp\" alt=\"Image: Stjerne legger opp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81464098&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=7.1428571428571&amp;panox=0&amp;heighty=0&amp;heightx=27.601809954751&amp;heightw=40.723981900452&amp;heighth=100&amp;width=402&amp;height=201&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">Stjerne</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">legger opp</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=\"Badelystne trosser advarsel\" href=\"https://www.dagbladet.no/nyheter/badelystne-trosser-advarsel/81460275\"><figure class=\"x__sc-1an7vu1-0 eMwOLg\"><picture><img data-defer=\"view\" title=\"Image: Badelystne trosser advarsel\" alt=\"Image: Badelystne trosser advarsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463321&amp;panox=0&amp;panow=100&amp;panoh=50.704225352113&amp;panoy=40.140845070423&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=321&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">Badelystne</span><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">trosser advarsel</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=\"Slaktet utøvere: - Må stå i det\" href=\"https://www.dagbladet.no/sport/ma-sta-i-det/81454401\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Slaktet utøvere: - Må stå i det\" alt=\"Image: Slaktet utøvere: - Må stå i det\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81454465&amp;panox=0.031298591549295&amp;panow=99.968701408451&amp;panoh=60.777778333333&amp;panoy=26.666666666667&amp;heighty=0&amp;heightx=32.835820895522&amp;heightw=34.676617164179&amp;heighth=99.955850331126&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\">Slaktet utøvere:</span><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">- Må stå i det</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kommentator i sjokk: - Jesus!\" href=\"https://www.dagbladet.no/video/slakter-arrangoren-elendig-sikkerhet/mnBg2771\"><figure class=\"x__sc-1an7vu1-0 bZIcOd moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Kommentator i sjokk: - Jesus!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81459856.jpg?imageId=81459856&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=189\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/27/0748cee0-dbfc-4eeb-a861-fab6cac60a63/gif_bestemor_rullator_sykkel_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/27/0748cee0-dbfc-4eeb-a861-fab6cac60a63/gif_bestemor_rullator_sykkel_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 erpCho title dynamic-sizing\">Kommentator i</span><span class=\"x__pt8tzk-0 erpCho title dynamic-sizing\">sjokk: - Jesus!</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 cBQWRq\"><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=225&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><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=\"Her får du parfyme og deo knallbillig\" href=\"https://tinyurl.com/parfyme30?allerID=1202505241\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Her får du parfyme og deo knallbillig\" alt=\"Image: Her får du parfyme og deo knallbillig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81445266.jpg?imageId=81445266&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 cyVXzf title dynamic-sizing\">Her får du parfyme</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">og deo knallbillig</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=\"Kastet av flyet: - Kvalmt\" href=\"https://www.dagbladet.no/kjendis/kastet-av-flyet-kvalmt/81455385\"><figure class=\"x__sc-1an7vu1-0 iNTUgw\"><picture><img data-defer=\"view\" title=\"Image: Kastet av flyet: - Kvalmt\" alt=\"Image: Kastet av flyet: - Kvalmt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81455394&amp;panoy=24.233128834356&amp;panow=99.842766981132&amp;panoh=22.290388343558&amp;panox=0&amp;heighty=0&amp;heightx=16.101694915254&amp;heightw=77.683615254237&amp;heighth=81.238615300546&amp;width=402&amp;height=300&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kpDSmG title dynamic-sizing\">Kastet av</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">flyet: - Kvalmt</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=\"Oppgjør med Fredrik Solvang\" href=\"https://www.dagbladet.no/nyheter/oppgjor-med-fredrik-solvang/81457062\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Oppgjør med Fredrik Solvang\" alt=\"Image: Oppgjør med Fredrik Solvang\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81457117&amp;panoy=13.698630136986&amp;panox=0.15151545454546&amp;panow=99.848484545455&amp;panoh=51.141552054795&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 hbwikt title dynamic-sizing\">Oppgjør med</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">Fredrik Solvang</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=\"Bryter sammen i tårer\" href=\"https://www.dagbladet.no/kjendis/bryter-sammen-i-tarer/81460697\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Bryter sammen i tårer\" alt=\"Image: Bryter sammen i tårer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81460776&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 bwzwBX title dynamic-sizing\">Bryter sammen</span><span class=\"x__pt8tzk-0 eyIQTS title dynamic-sizing\">i tårer</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skapte full forvirring\" href=\"https://www.dagbladet.no/nyheter/skapte-full-forvirring/81463222\"><figure class=\"x__sc-1an7vu1-0 hhSwZo\"><picture><img data-defer=\"view\" title=\"Image: Skapte full forvirring\" alt=\"Image: Skapte full forvirring\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463409&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=397&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jPbWVE title dynamic-sizing\">Skapte full</span><span class=\"x__pt8tzk-0 criDNb title dynamic-sizing\">forvirring</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-smartbanner2\" class=\"adunit-wrapper columns small-12 medium-12 large-12 track-element  \" data-from=\"xavier\"><div id=\"ad-smartbanner2\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600],[980,300],[970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;smartbanner2&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Hendelser ryster\" href=\"https://www.dagbladet.no/sport/hendelser-ryster/81456068\"><figure class=\"x__sc-1an7vu1-0 kdZLYR\"><picture><img data-defer=\"view\" title=\"Image: Hendelser ryster\" alt=\"Image: Hendelser ryster\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81456076&amp;panow=100&amp;panox=0&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=485&amp;height=378&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Hendelser ryster</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=\"- Var døende i tre uker\" href=\"https://www.dagbladet.no/sport/var-doende-i-tre-uker/81456438\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Var døende i tre uker\" alt=\"Image: - Var døende i tre uker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81456454&amp;panoy=26.428571428571&amp;panow=100&amp;panoh=50.714285714286&amp;panox=0&amp;heightx=27.306273062731&amp;heighty=7.182320441989&amp;heightw=33.210332103321&amp;heighth=81.21546961326&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">- Var døende</span><span class=\"x__pt8tzk-0 kLBvft title dynamic-sizing\">i tre uker</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=\"- Helt død i tre dager\" href=\"https://www.dagbladet.no/kjendis/helt-dod-i-tre-dager/81453284\"><figure class=\"x__sc-1an7vu1-0 bptmYL\"><picture><img data-defer=\"view\" title=\"Image: - Helt død i tre dager\" alt=\"Image: - Helt død i tre dager\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81453465&amp;panow=99.932614150943&amp;panoh=22.911050943396&amp;panoy=16.978238993711&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=37.541974479516&amp;heighty=6.178643384822&amp;width=402&amp;height=307&amp;compression=70\" 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\">- Helt død</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">i tre dager</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=\"Har fått nok: - Veldig trist\" href=\"https://www.dagbladet.no/sport/har-fatt-nok-veldig-trist/81444790\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Har fått nok: - Veldig trist\" alt=\"Image: Har fått nok: - Veldig trist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81444854&amp;panoy=10&amp;panow=100&amp;panoh=47.333333333333&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">Har fått nok:</span><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">- Veldig trist</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=\"Uskiftet bo: Unngå smell\" href=\"https://www.dagbladet.no/tema/uskiftet-bo-unnga-smell/81206199\"><figure class=\"x__sc-1an7vu1-0 hygKBp\"><picture><img data-defer=\"view\" title=\"Image: Uskiftet bo: Unngå smell\" alt=\"Image: Uskiftet bo: Unngå smell\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81246037&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;heightw=100&amp;width=320&amp;height=203&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 kNhGgX title dynamic-sizing\">Uskiftet bo:</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Unngå smell</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kom hjem til dette\" href=\"https://www.dagbladet.no/video/filmer-skrekksynet/Wpf4L3Vo\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Kom hjem til dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81459879.jpg?imageId=81459879&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/27/06553d23-6a1f-4667-be64-61af93f61ae6/gif2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/27/06553d23-6a1f-4667-be64-61af93f61ae6/gif2.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 dLwqhJ title dynamic-sizing\">Kom hjem</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">til dette</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=\"Gaven overrasker\" href=\"https://www.dagbladet.no/kjendis/gaven-overrasker/81462531\"><figure class=\"x__sc-1an7vu1-0 dPhbyL\"><picture><img data-defer=\"view\" title=\"Image: Gaven overrasker\" alt=\"Image: Gaven overrasker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81410949&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=454&amp;compression=70\" 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\">Gaven overrasker</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=\"Tragisk dødsfall\" href=\"https://www.dagbladet.no/sport/tragisk-dodsfall/81455443\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Tragisk dødsfall\" alt=\"Image: Tragisk dødsfall\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81455487&amp;panoy=58.43621399177&amp;panox=0&amp;panow=100&amp;panoh=29.218106995885&amp;heighty=0&amp;heightw=70.866141732283&amp;heighth=100&amp;heightx=11.023622047244&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\">Tragisk</span><span class=\"x__pt8tzk-0 ePuSwO title dynamic-sizing\">dødsfall</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=\"Sexfest-hovedstaden rammes av skandale\" href=\"https://www.dagbladet.no/nyheter/sexfest-hovedstaden-rammes-av-skandale/81459572\"><figure class=\"x__sc-1an7vu1-0 fYvkjy\"><picture><img data-defer=\"view\" title=\"Image: Sexfest-hovedstaden rammes av skandale\" alt=\"Image: Sexfest-hovedstaden rammes av skandale\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81459580&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;panoy=31.914893617021&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=328&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Sexfest-hovedstaden</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">rammes av skandale</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=\"Tiltale: Fant på bil-spor\" href=\"https://www.dagbladet.no/nyheter/tiltale-fant-pa-bil-spor/81445946\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Tiltale: Fant på bil-spor\" alt=\"Image: Tiltale: Fant på bil-spor\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81445968&amp;panow=100&amp;panoh=100&amp;panox=0&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=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 inhdgd title dynamic-sizing\">Tiltale: Fant</span><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">på bil-spor</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=\"Raser mot TV 2\" href=\"https://www.dagbladet.no/video/raser-mot-tv-2/2xzETyUN\"><figure class=\"x__sc-1an7vu1-0 dystQj\"><picture><img data-defer=\"view\" title=\"Image: Raser mot TV 2\" alt=\"Image: Raser mot TV 2\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/2xzETyUN-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Raser mot TV 2</span></h3></header></a></article><article class=\"preview columns small-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-medisin:Urovekkende funn\" href=\"https://www.dagbladet.no/tema/adhd-medisinurovekkende-funn/81349829\"><figure class=\"x__sc-1an7vu1-0 dystQj\"><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=217&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></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=\"Uttaler seg: - Helt knust\" href=\"https://www.dagbladet.no/kjendis/uttaler-seg-helt-knust/81459473\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Uttaler seg: - Helt knust\" alt=\"Image: Uttaler seg: - Helt knust\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81459661&amp;panox=0&amp;panow=100&amp;panoh=42.603550295858&amp;panoy=18.343195266272&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 dQSCBR title dynamic-sizing\">Uttaler seg:</span><span class=\"x__pt8tzk-0 gNDiBf title dynamic-sizing\">- Helt knust</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vekker oppsikt\" href=\"https://www.dagbladet.no/sport/vekker-oppsikt/81456639\"><figure class=\"x__sc-1an7vu1-0 cCuzIK\"><picture><img data-defer=\"view\" title=\"Image: Vekker oppsikt\" alt=\"Image: Vekker oppsikt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81456644&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=438&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Vekker oppsikt</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=\"Åpner opp om innleggelsen\" href=\"https://www.dagbladet.no/nyheter/apner-opp-om-innleggelsen/81458303\"><figure class=\"x__sc-1an7vu1-0 gSabaN\"><picture><img data-defer=\"view\" title=\"Image: Åpner opp om innleggelsen\" alt=\"Image: Åpner opp om innleggelsen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81458886&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=449&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Åpner opp om</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">innleggelsen</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ferdig i storklubb\" href=\"https://www.dagbladet.no/sport/ferdig-i-storklubb/81459556\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Ferdig i storklubb\" alt=\"Image: Ferdig i storklubb\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81459561&amp;panoy=26.428571428571&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightx=32.579185520362&amp;heightw=40.723981900452&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eDnlaH title dynamic-sizing\">Ferdig i</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">storklubb</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=\"Bildene «hele» Norge så\" href=\"https://www.dagbladet.no/video/bildene-hele-norge-sa/eMUs8yPN\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Bildene «hele» Norge så\" alt=\"Image: Bildene «hele» Norge så\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/eMUs8yPN-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Bildene «hele»</span><span class=\"x__pt8tzk-0 bHxiDg title dynamic-sizing\">Norge så</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" 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 17: Simens ti kjappe!\" href=\"https://www.dagbladet.no/nyheter/quiz-uke-17-simens-ti-kjappe/81313924\"><figure class=\"x__sc-1an7vu1-0 bqoCfD\"><picture><img data-defer=\"view\" title=\"Image: Quiz uke 17: Simens ti kjappe!\" alt=\"Image: Quiz uke 17: Simens ti kjappe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81056783&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=190&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dXa-DVQ title dynamic-sizing\">Quiz uke 17:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Simens ti kjappe!</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=\"Malte over minnesmerket søndag kveld\" href=\"https://www.dagbladet.no/nyheter/malte-over-minnesmerket-sondag-kveld/81455799\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Malte over minnesmerket søndag kveld\" alt=\"Image: Malte over minnesmerket søndag kveld\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81456780&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">Malte over</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">minnesmerket</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">søndag kveld</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=\"Avlyser\" href=\"https://www.dagbladet.no/kjendis/avlyser/81454939\"><figure class=\"x__sc-1an7vu1-0 dsbUeD\"><picture><img data-defer=\"view\" title=\"Image: Avlyser\" alt=\"Image: Avlyser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81454946&amp;panox=7.8066914498141&amp;panoy=1.123595505618&amp;panow=78.686492936803&amp;panoh=40.823969662921&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&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 inoUtg title dynamic-sizing\">Avlyser</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=\"Marius (35) omkom\" href=\"https://www.dagbladet.no/nyheter/marius-35-omkom/81463062\"><figure class=\"x__sc-1an7vu1-0 hWgrNA\"><picture><img data-defer=\"view\" title=\"Image: Marius (35) omkom\" alt=\"Image: Marius (35) omkom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81463128&amp;panoy=26.83615819209&amp;panox=21.052631578947&amp;panow=78.947368421053&amp;panoh=20.056497175141&amp;heightx=35.858585858586&amp;heightw=45.454545454545&amp;heighth=55.263157894737&amp;heighty=17.669172932331&amp;width=402&amp;height=462&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Marius (35) omkom</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=\"- Redd veggen skal rase\" href=\"https://www.dagbladet.no/nyheter/redd-veggen-skal-rase/81454689\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Redd veggen skal rase\" alt=\"Image: - Redd veggen skal rase\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81459287&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">- Redd veggen</span><span class=\"x__pt8tzk-0 iEukpb title dynamic-sizing\">skal rase</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=\"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=\"Absurd angrep\" href=\"https://www.dagbladet.no/video/bestemor-hyler/0njon8qj\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Absurd angrep\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81461035.jpg?imageId=81461035&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/28/11054ea2-8edb-4a23-895c-9dd2307e5d37/elggif3.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/28/11054ea2-8edb-4a23-895c-9dd2307e5d37/elggif3.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 erpCho title dynamic-sizing\">Absurd angrep</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Betaler titusener for å se Märtha\" href=\"https://www.dagbladet.no/kjendis/betaler-titusener-for-a-se-martha/81458391\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Betaler titusener for å se Märtha\" alt=\"Image: Betaler titusener for å se Märtha\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81458430&amp;panoh=53.82716&amp;panow=99.842766981132&amp;panoy=4.4444444444444&amp;panox=0.15723301886793&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 bvXqXn title dynamic-sizing\">Betaler titusener</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">for å se Märtha</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 ny jobb\" href=\"https://www.dagbladet.no/kjendis/roper-ny-jobb/81458321\"><figure class=\"x__sc-1an7vu1-0 edtodV\"><picture><img data-defer=\"view\" title=\"Image: Røper ny jobb\" alt=\"Image: Røper ny jobb\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81458328&amp;panoy=2.5210084033613&amp;panow=99.842766981132&amp;panoh=61.064425210084&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=301&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">Røper ny jobb</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer russerne\" href=\"https://www.dagbladet.no/video/advarer-russerne/YV1HwaxQ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advarer russerne\" alt=\"Image: Advarer russerne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/YV1HwaxQ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">Advarer</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">russerne</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gjeldsproblemer: Pengehjelpen fra Nav\" href=\"https://www.dagbladet.no/tema/gjeldsproblemer-pengehjelpen-fra-nav/81342721\"><figure class=\"x__sc-1an7vu1-0 iGqPLB\"><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=256&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-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=\"Droner skutt ned ved Putins luksuspalass\" href=\"https://www.dagbladet.no/nyheter/droner-skutt-ned-ved-putins-luksuspalass/81458388\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Droner skutt ned ved Putins luksuspalass\" alt=\"Image: Droner skutt ned ved Putins luksuspalass\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81458396&amp;panoy=40.833333333333&amp;panox=0&amp;panow=100&amp;panoh=59.166666666667&amp;heightx=19.37984496124&amp;heightw=34.883720930233&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 kMqJSM title dynamic-sizing\">Droner skutt ned ved</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">Putins luksuspalass</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 er det verst\" href=\"https://www.dagbladet.no/nyheter/her-er-det-verst/81464039\"><figure class=\"x__sc-1an7vu1-0 ifbRza\"><picture><img data-defer=\"view\" title=\"Image: Her er det verst\" alt=\"Image: Her er det verst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81461096&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=348&amp;compression=70\" 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\">Her er det verst</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=\"Kjærlighetssvindel: Deler de skjulte tegnene\" href=\"https://www.dagbladet.no/tema/ble-kjaerlighetssvindletdeler-de-skjulte-tegnene/81407038\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><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=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Kjærlighetssvindel:</span><span class=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Deler de skjulte tegnene</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-black\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Overvåker finskegrensa\" href=\"https://www.dagbladet.no/video/russiske-overvakningsballonger-ved-finland/zNlpuMUj\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Overvåker finskegrensa\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81461982.jpg?imageId=81461982&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/28/80cf3f78-e4f2-452c-b33e-68a1726c4342/gif_2_finland.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/28/80cf3f78-e4f2-452c-b33e-68a1726c4342/gif_2_finland.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 dLwqhJ title dynamic-sizing\">Overvåker</span><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">finskegrensa</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=\"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-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 jJDuNs\"><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=184&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 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-rectangle7\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle7\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Homse-uttalelse provoserer\" href=\"https://www.dagbladet.no/nyheter/homse-uttalelse-provoserer/81460208\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Homse-uttalelse provoserer\" alt=\"Image: Homse-uttalelse provoserer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81460960&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=5&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=23.181818181818&amp;heightw=40.909090909091&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 jdcGMN title dynamic-sizing\">Homse-uttalelse</span><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">provoserer</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=\"Kjempekøer på E18\" href=\"https://www.dagbladet.no/nyheter/kjempekoer-pa-e18/81458273\"><figure class=\"x__sc-1an7vu1-0 kbQZSd\"><picture><img data-defer=\"view\" title=\"Image: Kjempekøer på E18\" alt=\"Image: Kjempekøer på E18\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81458278&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=349&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">Kjempekøer på E18</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=\"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><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=\"Therese Johaug sjokkerer russeren\" href=\"https://www.dagbladet.no/video/russeren-trener-med-johaug-sa-skjer-dette/Ky20L531\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Therese Johaug sjokkerer russeren\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81452414.jpg?imageId=81452414&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/23/eb92461a-27d0-44a2-bf34-b44e3481e80c/gif_russland_tatyana.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/23/eb92461a-27d0-44a2-bf34-b44e3481e80c/gif_russland_tatyana.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 itkiNJ title dynamic-sizing\">Therese Johaug</span><span class=\"x__pt8tzk-0 fnuVOB title dynamic-sizing\">sjokkerer russeren</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=\"Ble buet ut\" href=\"https://www.dagbladet.no/nyheter/ble-buet-ut/81454875\"><figure class=\"x__sc-1an7vu1-0 bcRKOI\"><picture><img data-defer=\"view\" title=\"Image: Ble buet ut\" alt=\"Image: Ble buet ut\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81454882&amp;panow=53.553299492386&amp;panoh=27.586206896552&amp;panoy=9.5785440613027&amp;panox=2.5380710659898&amp;heighty=1.8927444794953&amp;heightx=19.747899159664&amp;heightw=18.90756302521&amp;heighth=46.372239747634&amp;width=402&amp;height=388&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">Ble buet ut</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=\"Reagerer: - Vis noe respekt\" href=\"https://www.dagbladet.no/sport/reagerer-vis-noe-respekt/81455459\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Vis noe respekt\" alt=\"Image: Reagerer: - Vis noe respekt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81455465&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=32.142857142857&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;heightx=25.339366515837&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 bwzwBX title dynamic-sizing\">Reagerer: - Vis</span><span class=\"x__pt8tzk-0 gNDiBf title dynamic-sizing\">noe respekt</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=\"Tror ikke det hun ser\" href=\"https://www.dagbladet.no/video/tror-ikke-det-hun-ser/04pdk1iH\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Tror ikke det hun ser\" alt=\"Image: Tror ikke det hun ser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/04pdk1iH-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 bkgkdp title dynamic-sizing\">Tror ikke</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">det hun ser</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=\"Fibromyalgi: Effektivt mot smerter\" href=\"https://www.dagbladet.no/tema/fibromyalgi-effektivt-mot-smerter/81342578\"><figure class=\"x__sc-1an7vu1-0 gkSegO\"><picture><img data-defer=\"view\" title=\"Image: Fibromyalgi: Effektivt mot smerter\" alt=\"Image: Fibromyalgi: Effektivt mot smerter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81365553&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=211&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dXa-DVQ title dynamic-sizing\">Fibromyalgi:</span><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Effektivt mot smerter</span></h3></header></a></article><div id=\"apos-medium-rectangle8\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bryter tausheten: - Angrer ikke\" href=\"https://www.dagbladet.no/kjendis/bryter-tausheten-angrer-ikke/81458936\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Bryter tausheten: - Angrer ikke\" alt=\"Image: Bryter tausheten: - Angrer ikke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81458948&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=27.947154268293&amp;heighth=81.238615300546&amp;heightx=37.19512195122&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 iLHueX title dynamic-sizing\">Bryter tausheten:</span><span class=\"x__pt8tzk-0 XaoDC title dynamic-sizing\">- Angrer ikke</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Så rødt: - En skandale\" href=\"https://www.dagbladet.no/sport/sa-rodt-en-skandale/81452547\"><figure class=\"x__sc-1an7vu1-0 jbIdpI\"><picture><img data-defer=\"view\" title=\"Image: Så rødt: - En skandale\" alt=\"Image: Så rødt: - En skandale\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81452941&amp;panow=88.983050847458&amp;panoh=45.806451612903&amp;panoy=23.225806451613&amp;panox=8.4745762711864&amp;heighty=7.3863636363636&amp;heightx=36.194029850746&amp;heightw=33.582089552239&amp;heighth=83.522727272727&amp;width=402&amp;height=277&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cUXKOF title dynamic-sizing\">Så rødt:</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- En skandale</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=\"Nytt rosacea-grep vekker oppsikt\" href=\"https://www.dagbladet.no/tema/nytt-rosacea-grep-vekker-oppsikt/81342868\"><figure class=\"x__sc-1an7vu1-0 kAAGbU\"><picture><img data-defer=\"view\" title=\"Image: Nytt rosacea-grep vekker oppsikt\" alt=\"Image: Nytt rosacea-grep vekker oppsikt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81344356&amp;panoy=16.129032258065&amp;panow=100&amp;panoh=45.161290322581&amp;panox=0&amp;heighty=0&amp;heightx=4.7120418848168&amp;heightw=46.073298429319&amp;heighth=100&amp;width=320&amp;height=183&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Nytt rosacea-grep</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">vekker oppsikt</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=\"De er sønnene\" href=\"https://www.dagbladet.no/video/de-er-sonnene/0WIF6AwQ\"><figure class=\"x__sc-1an7vu1-0 kAAGbU\"><picture><img data-defer=\"view\" title=\"Image: De er sønnene\" alt=\"Image: De er sønnene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/0WIF6AwQ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">De er sønnene</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Livredd for å stille opp\" href=\"https://www.dagbladet.no/video/slatt-i-sesongapningen/P8XJaHPn\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: - Livredd for å stille opp\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81452332.jpg?imageId=81452332&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/26/65433e83-48d7-46fe-9f58-8eae49605523/gif_2.0.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/26/65433e83-48d7-46fe-9f58-8eae49605523/gif_2.0.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfhrCI title dynamic-sizing\">- Livredd for</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">å stille opp</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=\"Angst: Slik får du uføretrygd\" href=\"https://www.dagbladet.no/tema/angst-slik-far-du-uforetrygd/81395578\"><figure class=\"x__sc-1an7vu1-0 jJDuNs\"><picture><img data-defer=\"view\" title=\"Image: Angst: Slik får du uføretrygd\" alt=\"Image: Angst: Slik får du uføretrygd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81395620&amp;panow=100.16181553398&amp;panoh=56.266672&amp;panoy=13.6&amp;panox=0.16181553398058&amp;heighty=0.23310489510489&amp;heightx=38.983050847458&amp;heightw=37.005652542373&amp;heighth=100.2331048951&amp;width=320&amp;height=184&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Angst: Slik får</span><span class=\"x__pt8tzk-0 iITVJY title dynamic-sizing\">du uføretrygd</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=\"Diagnosene som gir raskest uføretrygd\" href=\"https://www.dagbladet.no/tema/diagnosene-som-gir-raskest-uforetrygd/81368554\"><figure class=\"x__sc-1an7vu1-0 ibyVuT\"><picture><img data-defer=\"view\" title=\"Image: Diagnosene som gir raskest uføretrygd\" alt=\"Image: Diagnosene som gir raskest uføretrygd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80166524&amp;panox=0&amp;panow=99.757281553398&amp;panoh=47.931034482759&amp;panoy=23.236344827586&amp;heighty=0.34722222222222&amp;heightx=25.267401960784&amp;heightw=42.892156862745&amp;heighth=99.652777777778&amp;width=320&amp;height=180&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Diagnosene som gir</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">raskest uføretrygd</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=\"Eieren løper\" href=\"https://www.dagbladet.no/video/eieren-loper/wTB1RjUa\"><figure class=\"x__sc-1an7vu1-0 ibyVuT\"><picture><img data-defer=\"view\" title=\"Image: Eieren løper\" alt=\"Image: Eieren løper\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81462700.jpg?imageId=81462700&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=180&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"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 lplqa-d title dynamic-sizing\">Eieren løper</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=\"Politiet advarer turgåere\" href=\"https://www.dagbladet.no/video/politiet-advarer-turgaere/uzkKxP4P\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Politiet advarer turgåere\" alt=\"Image: Politiet advarer turgåere\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uzkKxP4P-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">Politiet</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">advarer turgåere</span></h3></header></a></article><article class=\"preview columns small-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=\"Psykologens metode: Forutser brudd på minutter\" href=\"https://www.dagbladet.no/tema/psykologens-metode-forutser-brudd-pa-minutter/81413345\"><figure class=\"x__sc-1an7vu1-0 iYOkok\"><picture><img data-defer=\"view\" title=\"Image: Psykologens metode: Forutser brudd på minutter\" alt=\"Image: Psykologens metode: Forutser brudd på minutter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81413615&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=166&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\">Psykologens</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">metode: Forutser</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">brudd på minutter</span></h3></header></a></article><div id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12 bg-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=\"Kommer fra dypet\" href=\"https://www.dagbladet.no/video/kommer-fra-dypet/7YeC3g1K\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Kommer fra dypet\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81455061.jpg?imageId=81455061&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/24/9469d0d9-c8f2-4735-a72f-2f55f88df603/gif1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/24/9469d0d9-c8f2-4735-a72f-2f55f88df603/gif1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 BsLeO title dynamic-sizing\">Kommer fra dypet</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=\"Rasmus&#x27; magefett-formel: Kiloene raser\" href=\"https://www.dagbladet.no/tema/rasmus-magefett-formel-kiloene-raser/81394145\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Rasmus&#x27; magefett-formel: Kiloene raser\" alt=\"Image: Rasmus&#x27; magefett-formel: Kiloene raser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81402423&amp;panoy=0&amp;panox=8.0321285140562&amp;panow=87.550200803213&amp;panoh=100&amp;heighty=0&amp;heightx=40.661478599222&amp;heightw=18.287937743191&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 jRIgeY title dynamic-sizing\">Rasmus&#x27; magefett-formel:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Kiloene raser</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=\"Hisser på seg «alle»\" href=\"https://www.dagbladet.no/video/hisser-pa-seg-alle/dfNrj5np\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Hisser på seg «alle»\" alt=\"Image: Hisser på seg «alle»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/dfNrj5np-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 jGSTdz title dynamic-sizing\">Hisser på</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">seg «alle»</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Atopisk eksem: Hudlege hyller Mys (19) metode\" href=\"https://www.dagbladet.no/tema/atopisk-eksem-hudlege-hyller-mys-19-metode/81239665\"><figure class=\"x__sc-1an7vu1-0 jOMhbl\"><picture><img data-defer=\"view\" title=\"Image: Atopisk eksem: Hudlege hyller Mys (19) metode\" alt=\"Image: Atopisk eksem: Hudlege hyller Mys (19) metode\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81253932&amp;panoy=24.576271186441&amp;panow=49.881235154394&amp;panoh=60.169491525424&amp;panox=25.653206650831&amp;heighty=6.4327485380117&amp;heightx=33.277027027027&amp;heightw=15.202702702703&amp;heighth=86.470588235294&amp;width=320&amp;height=244&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 kmxpNq title dynamic-sizing\">Atopisk eksem: Hudlege</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">hyller Mys (19) metode</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>"]