["<style>.cmmZIV.cmmZIV.cmmZIV.cmmZIV{height:0;padding-bottom:55%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .BSTEG.BSTEG.BSTEG.BSTEG{height:0;padding-bottom:72.37%;}/*!sc*/ .bCBnLv.bCBnLv.bCBnLv.bCBnLv{height:0;padding-bottom:57.31%;}/*!sc*/ .bbtmgY.bbtmgY.bbtmgY.bbtmgY{height:0;padding-bottom:82.81%;}/*!sc*/ .fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .dhfOYC.dhfOYC.dhfOYC.dhfOYC{height:0;padding-bottom:84.32%;}/*!sc*/ .hlqDzP.hlqDzP.hlqDzP.hlqDzP{height:0;padding-bottom:54.72%;}/*!sc*/ .QgvhR.QgvhR.QgvhR.QgvhR{height:0;padding-bottom:53.19%;}/*!sc*/ .iBNrRz.iBNrRz.iBNrRz.iBNrRz{height:0;padding-bottom:54.49%;}/*!sc*/ .kfneRi.kfneRi.kfneRi.kfneRi{height:0;padding-bottom:68.12%;}/*!sc*/ .cBQWRq.cBQWRq.cBQWRq.cBQWRq{height:0;padding-bottom:70.31%;}/*!sc*/ .icNEag.icNEag.icNEag.icNEag{height:0;padding-bottom:74.84%;}/*!sc*/ .edsdSp.edsdSp.edsdSp.edsdSp{height:0;padding-bottom:57.73%;}/*!sc*/ .elmUEl.elmUEl.elmUEl.elmUEl{height:0;padding-bottom:53.48%;}/*!sc*/ .evkaIe.evkaIe.evkaIe.evkaIe{height:0;padding-bottom:70.64%;}/*!sc*/ .iBoTJJ.iBoTJJ.iBoTJJ.iBoTJJ{height:0;padding-bottom:75.62%;}/*!sc*/ .jBkyoY.jBkyoY.jBkyoY.jBkyoY{height:0;padding-bottom:82.18%;}/*!sc*/ .qUoPe.qUoPe.qUoPe.qUoPe{height:0;padding-bottom:105.72%;}/*!sc*/ .cnEQEw.cnEQEw.cnEQEw.cnEQEw{height:0;padding-bottom:85.82%;}/*!sc*/ .gFiTCV.gFiTCV.gFiTCV.gFiTCV{height:0;padding-bottom:51.13%;}/*!sc*/ .eXBGtj.eXBGtj.eXBGtj.eXBGtj{height:0;padding-bottom:58.45%;}/*!sc*/ .jUYClY.jUYClY.jUYClY.jUYClY{height:0;padding-bottom:54.06%;}/*!sc*/ .idKCHs.idKCHs.idKCHs.idKCHs{height:0;padding-bottom:50.93%;}/*!sc*/ .kbQZSd.kbQZSd.kbQZSd.kbQZSd{height:0;padding-bottom:71.95%;}/*!sc*/ .jcwGZQ.jcwGZQ.jcwGZQ.jcwGZQ{height:0;padding-bottom:84.74%;}/*!sc*/ .htBhCB.htBhCB.htBhCB.htBhCB{height:0;padding-bottom:89.3%;}/*!sc*/ .hRlocb.hRlocb.hRlocb.hRlocb{height:0;padding-bottom:57.46%;}/*!sc*/ .irXEZL.irXEZL.irXEZL.irXEZL{height:0;padding-bottom:96.25%;}/*!sc*/ .gQoIpx.gQoIpx.gQoIpx.gQoIpx{height:0;padding-bottom:69.27%;}/*!sc*/ .hBxfWp.hBxfWp.hBxfWp.hBxfWp{height:0;padding-bottom:103.73%;}/*!sc*/ .ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .dAPHKR.dAPHKR.dAPHKR.dAPHKR{height:0;padding-bottom:58.96%;}/*!sc*/ .jTuAlm.jTuAlm.jTuAlm.jTuAlm{height:0;padding-bottom:50.62%;}/*!sc*/ .eIlDNY.eIlDNY.eIlDNY.eIlDNY{height:0;padding-bottom:51.56%;}/*!sc*/ .hPMFKU.hPMFKU.hPMFKU.hPMFKU{height:0;padding-bottom:86.81%;}/*!sc*/ .dZwFXb.dZwFXb.dZwFXb.dZwFXb{height:0;padding-bottom:56.87%;}/*!sc*/ .jyPXHD.jyPXHD.jyPXHD.jyPXHD{height:0;padding-bottom:75.93%;}/*!sc*/ .ioOUcG.ioOUcG.ioOUcG.ioOUcG{height:0;padding-bottom:60.61%;}/*!sc*/ .kzGLIr.kzGLIr.kzGLIr.kzGLIr{height:0;padding-bottom:74.12%;}/*!sc*/ .lcWYHB.lcWYHB.lcWYHB.lcWYHB{height:0;padding-bottom:63.12%;}/*!sc*/ .gmpxUf.gmpxUf.gmpxUf.gmpxUf{height:0;padding-bottom:55.62%;}/*!sc*/ .fwaYEb.fwaYEb.fwaYEb.fwaYEb{height:0;padding-bottom:123.88%;}/*!sc*/ .hjJzLP.hjJzLP.hjJzLP.hjJzLP{height:0;padding-bottom:67.5%;}/*!sc*/ .hygKBp.hygKBp.hygKBp.hygKBp{height:0;padding-bottom:63.43%;}/*!sc*/ .iEicaO.iEicaO.iEicaO.iEicaO{height:0;padding-bottom:53.43%;}/*!sc*/ data-styled.g367[id=\"x__sc-1an7vu1-0\"]{content:\"cmmZIV,fnQDHb,BSTEG,bCBnLv,bbtmgY,fjJyvE,kviAry,dhfOYC,hlqDzP,QgvhR,iBNrRz,kfneRi,cBQWRq,icNEag,edsdSp,elmUEl,evkaIe,iBoTJJ,jBkyoY,qUoPe,cnEQEw,gFiTCV,eXBGtj,jUYClY,idKCHs,kbQZSd,jcwGZQ,htBhCB,hRlocb,irXEZL,gQoIpx,hBxfWp,ejnyBo,dAPHKR,jTuAlm,eIlDNY,hPMFKU,dZwFXb,jyPXHD,ioOUcG,kzGLIr,lcWYHB,gmpxUf,fwaYEb,hjJzLP,hygKBp,iEicaO,\"}/*!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*/ .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*/ .lfBuL.lfBuL.lfBuL.lfBuL{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.lfBuL.lfBuL.lfBuL.lfBuL{font-size:1.3em!important;}}/*!sc*/ .gpXVuT.gpXVuT.gpXVuT.gpXVuT{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gpXVuT.gpXVuT.gpXVuT.gpXVuT{font-size:2.2em!important;}}/*!sc*/ .jZttLu.jZttLu.jZttLu.jZttLu{font-size:7.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.jZttLu.jZttLu.jZttLu.jZttLu{font-size:2.8em!important;}}/*!sc*/ .kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:1.3em!important;}}/*!sc*/ .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*/ .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*/ .cWfsnL.cWfsnL.cWfsnL.cWfsnL{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cWfsnL.cWfsnL.cWfsnL.cWfsnL{font-size:3.1em!important;}}/*!sc*/ .fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:0.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .hRdvzd.hRdvzd.hRdvzd.hRdvzd{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.hRdvzd.hRdvzd.hRdvzd.hRdvzd{font-size:1.5em!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*/ .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*/ .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*/ .bvsVFh.bvsVFh.bvsVFh.bvsVFh{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvsVFh.bvsVFh.bvsVFh.bvsVFh{font-size:2.5em!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*/ .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*/ .glOqqI.glOqqI.glOqqI.glOqqI{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.glOqqI.glOqqI.glOqqI.glOqqI{font-size:1.4em!important;}}/*!sc*/ .fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:1.5em!important;}}/*!sc*/ .eQgupK.eQgupK.eQgupK.eQgupK{font-size:8.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQgupK.eQgupK.eQgupK.eQgupK{font-size:3em!important;}}/*!sc*/ .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*/ .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*/ .cVLSdA.cVLSdA.cVLSdA.cVLSdA{font-size:9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cVLSdA.cVLSdA.cVLSdA.cVLSdA{font-size:3.2em!important;}}/*!sc*/ .iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:1em!important;}}/*!sc*/ .zWscE.zWscE.zWscE.zWscE{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.zWscE.zWscE.zWscE.zWscE{font-size:0.7em!important;}}/*!sc*/ .gjHDge.gjHDge.gjHDge.gjHDge{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gjHDge.gjHDge.gjHDge.gjHDge{font-size:0.8em!important;}}/*!sc*/ .kukeCs.kukeCs.kukeCs.kukeCs{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kukeCs.kukeCs.kukeCs.kukeCs{font-size:2.2em!important;}}/*!sc*/ .ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:2.8em!important;}}/*!sc*/ .dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:1.2em!important;}}/*!sc*/ .jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:1.4em!important;}}/*!sc*/ .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*/ .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*/ .cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:1.5em!important;}}/*!sc*/ .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*/ .iAotPC.iAotPC.iAotPC.iAotPC{font-size:8.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iAotPC.iAotPC.iAotPC.iAotPC{font-size:3.2em!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*/ .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*/ .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*/ .bSlVPf.bSlVPf.bSlVPf.bSlVPf{font-size:10em!important;}/*!sc*/ @media only screen and (max-width:640px){.bSlVPf.bSlVPf.bSlVPf.bSlVPf{font-size:3.5em!important;}}/*!sc*/ .kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:8.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:2.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .kmfDed.kmfDed.kmfDed.kmfDed{font-size:8.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kmfDed.kmfDed.kmfDed.kmfDed{font-size:3.1em!important;}}/*!sc*/ .eCHIew.eCHIew.eCHIew.eCHIew{font-size:9.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.eCHIew.eCHIew.eCHIew.eCHIew{font-size:3.5em!important;}}/*!sc*/ .jiGVVj.jiGVVj.jiGVVj.jiGVVj{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.jiGVVj.jiGVVj.jiGVVj.jiGVVj{font-size:1.2em!important;}}/*!sc*/ .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*/ .eQoVaS.eQoVaS.eQoVaS.eQoVaS{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQoVaS.eQoVaS.eQoVaS.eQoVaS{font-size:2em!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*/ .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*/ .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*/ .dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:1.6em!important;}}/*!sc*/ .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*/ .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*/ .ijicdz.ijicdz.ijicdz.ijicdz{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ijicdz.ijicdz.ijicdz.ijicdz{font-size:1em!important;}}/*!sc*/ .iliEgZ.iliEgZ.iliEgZ.iliEgZ{font-size:9.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iliEgZ.iliEgZ.iliEgZ.iliEgZ{font-size:3.4em!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*/ .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*/ .ihkPAv.ihkPAv.ihkPAv.ihkPAv{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.ihkPAv.ihkPAv.ihkPAv.ihkPAv{font-size:0.8em!important;}}/*!sc*/ .bBNPyh.bBNPyh.bBNPyh.bBNPyh{font-size:12.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bBNPyh.bBNPyh.bBNPyh.bBNPyh{font-size:4.5em!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*/ .bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:1.5em!important;}}/*!sc*/ .jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:1.3em!important;}}/*!sc*/ .kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:2.2em!important;}}/*!sc*/ .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*/ .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*/ .gbeFJE.gbeFJE.gbeFJE.gbeFJE{font-size:9.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.gbeFJE.gbeFJE.gbeFJE.gbeFJE{font-size:3.4em!important;}}/*!sc*/ .fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:7.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:2.8em!important;}}/*!sc*/ .kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:0.7em!important;}}/*!sc*/ .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*/ .iNHyie.iNHyie.iNHyie.iNHyie{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.iNHyie.iNHyie.iNHyie.iNHyie{font-size:0.7em!important;}}/*!sc*/ data-styled.g368[id=\"x__pt8tzk-0\"]{content:\"iYgBvA,kVJNPR,lfBuL,gpXVuT,jZttLu,kMqJSM,kauVAS,dfgvpn,cWfsnL,fNDhDy,dPoeFo,dXa-DVQ,dfserP,hRdvzd,hQxAYP,ctWqNs,inhdgd,bvsVFh,dLwqhJ,tqGkg,glOqqI,fTAjeM,eQgupK,ddbCJZ,LzBnW,cVLSdA,iXjdLY,ftetSQ,epoJzD,gPIxea,iFlEmK,zWscE,gjHDge,kukeCs,ggbHpa,dyaAfc,jGSTdz,hrVcDN,dDKeDQ,bwGQrt,bcCfuJ,jEhvtw,bWSnVS,cJcNIn,gVRWAB,iAotPC,jdgMzU,bkgkdp,gNDiBf,bSlVPf,kUqUJf,fFAiTK,hsPeia,kNhGgX,kmxpNq,jfcAvK,kmfDed,eCHIew,jiGVVj,jtCXvA,eQoVaS,kpDSmG,jfvMWJ,inoUtg,dBWQRi,jdcGMN,inksEV,ijicdz,iliEgZ,cFtCN,cyVXzf,frzFun,ihkPAv,bBNPyh,lplqa-d,bNRoJL,jIyTDK,kyzRFP,gLHLEv,ggUSon,gbeFJE,fZJFvq,kwLuaB,Uccen,iNHyie,\"}/*!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=\"Uføretrygd: Denne feilen koster dyrt\" href=\"https://www.dagbladet.no/tema/uforetrygd-formelen-unnga-7-feller/81316099\"><figure class=\"x__sc-1an7vu1-0 cmmZIV\"><picture><img data-defer=\"view\" title=\"Image: Uføretrygd: Denne feilen koster dyrt\" alt=\"Image: Uføretrygd: Denne feilen koster dyrt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81320125&amp;panoy=42.763157894737&amp;panow=100&amp;panoh=48.684210526316&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=176&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\">Uføretrygd: Denne</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">feilen koster dyrt</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=\"Går til værs\" href=\"https://www.dagbladet.no/video/loveungen-sliter/MEsWrI6g\"><figure class=\"x__sc-1an7vu1-0 cmmZIV moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Går til værs\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81342053.jpg?imageId=81342053&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=176\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/11/06/662beab8-a048-4cf7-b023-9dcfc29ec715/gif4.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/11/06/662beab8-a048-4cf7-b023-9dcfc29ec715/gif4.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 lfBuL title dynamic-sizing\">Går til værs</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Beruset på direkten\" href=\"https://www.dagbladet.no/sport/beruset-pa-direkten/81345670\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Beruset på direkten\" alt=\"Image: Beruset på direkten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345675&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=25.714285714286&amp;panox=0&amp;heighty=0&amp;heightx=33.93665158371&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gpXVuT title dynamic-sizing\">Beruset på</span><span class=\"x__pt8tzk-0 jZttLu title dynamic-sizing\">direkten</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=\"Skjerper reiseråd: Nå svarer Malmö\" href=\"https://www.dagbladet.no/nyheter/skjerper-reiserad-na-svarer-malmo/81345129\"><figure class=\"x__sc-1an7vu1-0 BSTEG\"><picture><img data-defer=\"view\" title=\"Image: Skjerper reiseråd: Nå svarer Malmö\" alt=\"Image: Skjerper reiseråd: Nå svarer Malmö\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345144&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=30.316742081448&amp;width=485&amp;height=351&amp;compression=70\" 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\">Skjerper reiseråd:</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">Nå svarer Malmö</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=\"Skjult hint: - Det sier alt\" href=\"https://www.dagbladet.no/kjendis/skjult-hint-det-sier-alt/81338783\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Skjult hint: - Det sier alt\" alt=\"Image: Skjult hint: - Det sier alt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339822&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=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 kauVAS title dynamic-sizing\">Skjult hint:</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">- Det sier alt</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=\"Ny jobb\" href=\"https://www.dagbladet.no/sport/ny-jobb/81347133\"><figure class=\"x__sc-1an7vu1-0 bCBnLv\"><picture><img data-defer=\"view\" title=\"Image: Ny jobb\" alt=\"Image: Ny jobb\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81347139&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=10.714285714286&amp;heighty=0&amp;heightx=11.31221719457&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=278&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cWfsnL title dynamic-sizing\">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=\"Brutale kamper: - Mistet flere brigader\" href=\"https://www.dagbladet.no/video/brutale-kamper-mistet-flere-brigader/kAkEx7tx\"><figure class=\"x__sc-1an7vu1-0 bbtmgY\"><picture><img data-defer=\"view\" title=\"Image: Brutale kamper: - Mistet flere brigader\" alt=\"Image: Brutale kamper: - Mistet flere brigader\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kAkEx7tx-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Brutale kamper:</span><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">- Mistet flere brigader</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=\"Martins (71) demens-grep: Helt frisk\" href=\"https://www.dagbladet.no/tema/martins-71-demens-grep-helt-frisk/81274253\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Martins (71) demens-grep: Helt frisk\" alt=\"Image: Martins (71) demens-grep: Helt frisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81274882&amp;panoy=27.542372881356&amp;panox=0&amp;panow=100&amp;panoh=30.084745762712&amp;heightw=61.224489795918&amp;heighth=88.55421686747&amp;heighty=5.421686746988&amp;heightx=21.08843537415&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 dXa-DVQ title dynamic-sizing\">Martins (71)</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">demens-grep:</span><span class=\"x__pt8tzk-0 hRdvzd title dynamic-sizing\">Helt frisk</span></h3></header></a></article><div id=\"apos-medium-rectangle3\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Deler detaljer fra sexlivet\" href=\"https://www.dagbladet.no/kjendis/deler-detaljer-fra-sexlivet/81342175\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Deler detaljer fra sexlivet\" alt=\"Image: Deler detaljer fra sexlivet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342786&amp;panow=99.842766981132&amp;panoh=34.276729245283&amp;panoy=6.6037735849057&amp;panox=0&amp;heighty=0&amp;heightx=4.6979865771812&amp;heightw=61.521252348993&amp;heighth=99.77628590604&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">Deler detaljer</span><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">fra sexlivet</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=\"Reagerer: - Det er en ære\" href=\"https://www.dagbladet.no/kjendis/reagerer-det-er-en-aere/81337569\"><figure class=\"x__sc-1an7vu1-0 dhfOYC\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Det er en ære\" alt=\"Image: Reagerer: - Det er en ære\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338362&amp;panoy=25.764192139738&amp;panox=0&amp;panow=99.842766981132&amp;panoh=15.866084279476&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=339&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inhdgd title dynamic-sizing\">Reagerer:</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">- Det er en ære</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=\"Avviser vennskap\" href=\"https://www.dagbladet.no/kjendis/avviser-vennskap/81332289\"><figure class=\"x__sc-1an7vu1-0 hlqDzP\"><picture><img data-defer=\"view\" title=\"Image: Avviser vennskap\" alt=\"Image: Avviser vennskap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81332380&amp;panoy=3.030303030303&amp;panow=99.842766981132&amp;panoh=44.040403636364&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=220&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bvsVFh title dynamic-sizing\">Avviser</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">vennskap</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dramatisk hendelse - kamp avbrutt\" href=\"https://www.dagbladet.no/sport/dramatisk-hendelse-kamp-avbrutt/81347248\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dramatisk hendelse - kamp avbrutt\" alt=\"Image: Dramatisk hendelse - kamp avbrutt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81347253&amp;panow=100&amp;panoy=47.794117647059&amp;panox=0&amp;panoh=52.205882352941&amp;heightx=29.515418502203&amp;heightw=39.647577092511&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 dLwqhJ title dynamic-sizing\">Dramatisk hendelse</span><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">- kamp avbrutt</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=\"Jagerflyet går i lufta\" href=\"https://www.dagbladet.no/video/jagerflyet-gar-i-lufta/qocxhxds\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Jagerflyet går i lufta\" alt=\"Image: Jagerflyet går i lufta\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/qocxhxds-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 glOqqI title dynamic-sizing\">Jagerflyet</span><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">går i lufta</span></h3></header></a></article><article class=\"preview columns small-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=\"Fellene: Banken spiser pensjonen\" href=\"https://www.dagbladet.no/tema/fellene-banken-spiser-pensjonen/81173450\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Fellene: Banken spiser pensjonen\" alt=\"Image: Fellene: Banken spiser pensjonen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81153720&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 fNDhDy title dynamic-sizing\">Fellene: Banken</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">spiser pensjonen</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=\"Funn av død person\" href=\"https://www.dagbladet.no/nyheter/funn-av-dod-person/81345229\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Funn av død person\" alt=\"Image: Funn av død person\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345491&amp;panox=0.4739336492891&amp;panoy=15.107913669065&amp;panow=99.526066350711&amp;panoh=51.079136690647&amp;heightx=26.666666666667&amp;heightw=40&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 eQgupK title dynamic-sizing\">Funn av</span><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">død person</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sønnen vekker oppsikt\" href=\"https://www.dagbladet.no/kjendis/sonnen-vekker-oppsikt/81334220\"><figure class=\"x__sc-1an7vu1-0 QgvhR\"><picture><img data-defer=\"view\" title=\"Image: Sønnen vekker oppsikt\" alt=\"Image: Sønnen vekker oppsikt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81331485&amp;panoy=13.913043478261&amp;panox=0&amp;panow=100&amp;panoh=30.869565217391&amp;heightw=100&amp;heighty=0&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=258&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Sønnen vekker</span><span class=\"x__pt8tzk-0 cVLSdA title dynamic-sizing\">oppsikt</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=\"Måper: - Galskap\" href=\"https://www.dagbladet.no/sport/maper-galskap/81342119\"><figure class=\"x__sc-1an7vu1-0 iBNrRz\"><picture><img data-defer=\"view\" title=\"Image: Måper: - Galskap\" alt=\"Image: Måper: - Galskap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342192&amp;panow=81.395348837209&amp;panoh=41.279069767442&amp;panoy=37.209302325581&amp;panox=0&amp;heighty=13.068181818182&amp;heightx=30.30303030303&amp;heightw=34.090909090909&amp;heighth=83.522727272727&amp;width=567&amp;height=309&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">Måper: - Galskap</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=\"Vil etablere forskningssenter i  «spøkelsesby»\" href=\"https://www.dagbladet.no/nyheter/vil-etablere-forskningssenter-i-spokelsesby/81335828\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Vil etablere forskningssenter i  «spøkelsesby»\" alt=\"Image: Vil etablere forskningssenter i  «spøkelsesby»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335835&amp;panoy=61.25&amp;panox=0&amp;panow=100&amp;panoh=22.1875&amp;heighty=39.464882943144&amp;heightw=46.39175257732&amp;heighth=49.163879598662&amp;heightx=21.649484536082&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 ftetSQ title dynamic-sizing\">Vil etablere</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">forskningssenter</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">i  «spøkelsesby»</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=\"Innrømmer «juks» i NRK-program\" href=\"https://www.dagbladet.no/video/innrommer-juks-i-nrk-program/lMkzrfpg\"><figure class=\"x__sc-1an7vu1-0 kfneRi\"><picture><img data-defer=\"view\" title=\"Image: Innrømmer «juks» i NRK-program\" alt=\"Image: Innrømmer «juks» i NRK-program\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/lMkzrfpg-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Innrømmer «juks»</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">i NRK-program</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sjøgrens: Ta disse tegnene på alvor\" href=\"https://www.dagbladet.no/tema/sjogrens-ta-disse-tegnene-pa-alvor/81333224\"><figure class=\"x__sc-1an7vu1-0 cBQWRq\"><picture><img data-defer=\"view\" title=\"Image: Sjøgrens: Ta disse tegnene på alvor\" alt=\"Image: Sjøgrens: Ta disse tegnene på alvor\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342634&amp;panoy=20.567375886525&amp;panox=0&amp;panow=100&amp;panoh=49.645390070922&amp;heightw=42.105263157895&amp;heighth=100&amp;heightx=30.143540669856&amp;heighty=0&amp;width=320&amp;height=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 zWscE title dynamic-sizing\">Sjøgrens: Ta disse</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">tegnene på alvor</span></h3></header></a></article><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=\"Så mye får du for boligen din nå\" href=\"https://www.dagbladet.no/annonse/sjekk-hva-boligen-din-er-verdt-helt-gratis/79778531?allerID=1202404106\"><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: Så mye får du for boligen din nå\" alt=\"Image: Så mye får du for boligen din nå\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81240085.jpg?imageId=81240085&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 kVJNPR title dynamic-sizing\">Så mye får du for</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">boligen din nå</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Døde etter maraton\" href=\"https://www.dagbladet.no/kjendis/dode-etter-maraton/81340262\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Døde etter maraton\" alt=\"Image: Døde etter maraton\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81340479&amp;panoy=26.515151515152&amp;panox=0&amp;panow=99.842766981132&amp;panoh=27.525252272727&amp;heightw=77.030811764706&amp;heighth=99.77628590604&amp;heighty=0&amp;heightx=15.126050420168&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 kukeCs title dynamic-sizing\">Døde etter</span><span class=\"x__pt8tzk-0 ggbHpa title dynamic-sizing\">maraton</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=\"Overtalte mannen: - Lever bare en gang\" href=\"https://www.dagbladet.no/kjendis/overtalte-mannen-lever-bare-en-gang/81339840\"><figure class=\"x__sc-1an7vu1-0 icNEag\"><picture><img data-defer=\"view\" title=\"Image: Overtalte mannen: - Lever bare en gang\" alt=\"Image: Overtalte mannen: - Lever bare en gang\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81337789&amp;panox=16.387959866221&amp;panoy=11.557788944724&amp;panow=70.234113712375&amp;panoh=35.678391959799&amp;heightx=30.196078431373&amp;heightw=35.294117647059&amp;heighth=85.964912280702&amp;heighty=5.8479532163743&amp;width=485&amp;height=363&amp;compression=70\" 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\">Overtalte mannen:</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">- Lever bare en gang</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=\"- Hva faen feiler det folk?\" href=\"https://www.dagbladet.no/nyheter/hva-faen-feiler-det-folk/81344286\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Hva faen feiler det folk?\" alt=\"Image: - Hva faen feiler det folk?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81344463&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 kukeCs title dynamic-sizing\">- Hva faen</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">feiler det folk?</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=\"Til legevakta: - Skulle tøffe meg\" href=\"https://www.dagbladet.no/kjendis/til-legevakta-skulle-toffe-meg/81342878\"><figure class=\"x__sc-1an7vu1-0 edsdSp\"><picture><img data-defer=\"view\" title=\"Image: Til legevakta: - Skulle tøffe meg\" alt=\"Image: Til legevakta: - Skulle tøffe meg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343186&amp;panoy=14.285714285714&amp;panow=64.220183486239&amp;panoh=32.718894009217&amp;panox=28.746177370031&amp;heighty=0&amp;heightx=48.868778280543&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=280&amp;compression=70\" 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\">Til legevakta:</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">- Skulle tøffe meg</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=\"Advarer mot matvarer: Gir uren hud \" href=\"https://www.dagbladet.no/tema/advarer-mot-matvarer-gir-uren-hud/81273523\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advarer mot matvarer: Gir uren hud \" alt=\"Image: Advarer mot matvarer: Gir uren hud \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342684&amp;panox=0&amp;panow=100&amp;panoh=51.094890510949&amp;panoy=14.598540145985&amp;heighth=100&amp;heighty=0&amp;heightx=46.976744186047&amp;heightw=40.93023255814&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Advarer mot matvarer:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Gir uren hud </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=\"Her har du sett henne før\" href=\"https://www.dagbladet.no/video/her-har-du-sett-henne-for/6QYNfB3j\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Her har du sett henne før\" alt=\"Image: Her har du sett henne før\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/6QYNfB3j-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">Her har du</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">sett henne før</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=\"Etterlysning forskrekker: - Verste jeg har sett\" href=\"https://www.dagbladet.no/nyheter/etterlysning-forskrekker-verste-jeg-har-sett/81338335\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Etterlysning forskrekker: - Verste jeg har sett\" alt=\"Image: Etterlysning forskrekker: - Verste jeg har sett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338360&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=34.027778846154&amp;panoy=31.25&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 jEhvtw title dynamic-sizing\">Etterlysning forskrekker:</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">- Verste jeg har sett</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Trussel under Moskva\" href=\"https://www.dagbladet.no/nyheter/trussel-under-moskva/81341347\"><figure class=\"x__sc-1an7vu1-0 elmUEl\"><picture><img data-defer=\"view\" title=\"Image: Trussel under Moskva\" alt=\"Image: Trussel under Moskva\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341473&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=215&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bvsVFh title dynamic-sizing\">Trussel</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">under Moskva</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=\"- Barna dine skal se dette\" href=\"https://www.dagbladet.no/kjendis/barna-dine-skal-se-dette/81337738\"><figure class=\"x__sc-1an7vu1-0 evkaIe\"><picture><img data-defer=\"view\" title=\"Image: - Barna dine skal se dette\" alt=\"Image: - Barna dine skal se dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338029&amp;panow=100&amp;panoh=26.996197718631&amp;panoy=46.768060836502&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=284&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cJcNIn title dynamic-sizing\">- Barna dine</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">skal se dette</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vill jubel\" href=\"https://www.dagbladet.no/sport/vill-jubel/81346778\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Vill jubel\" alt=\"Image: Vill jubel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81347156&amp;panow=100&amp;panoh=50.714285714286&amp;panox=0&amp;panoy=7.8571428571429&amp;heighty=0&amp;heightx=24.545454545455&amp;heightw=40.909090909091&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 iAotPC title dynamic-sizing\">Vill jubel</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=\"Står frem etter skandalebilder\" href=\"https://www.dagbladet.no/video/star-frem-etter-skandalebilder/fjjA4oX5\"><figure class=\"x__sc-1an7vu1-0 iBoTJJ\"><picture><img data-defer=\"view\" title=\"Image: Står frem etter skandalebilder\" alt=\"Image: Står frem etter skandalebilder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/fjjA4oX5-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Står frem etter</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">skandalebilder</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=\"Høytrykkspyler-vinner: - Gjør rent bord!\" href=\"https://www.dagbladet.no/tema/hoytrykkspyler-vinner-gjor-rent-bord/81067765\"><figure class=\"x__sc-1an7vu1-0 jBkyoY\"><picture><img data-defer=\"view\" title=\"Image: Høytrykkspyler-vinner: - Gjør rent bord!\" alt=\"Image: Høytrykkspyler-vinner: - Gjør rent bord!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75958864&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=320&amp;height=263&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Høytrykkspyler-vinner:</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">- Gjør rent bord!</span></h3></header></a></article><article class=\"preview columns small-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=\"Megasalg hos Tights.no\" href=\"https://tinyurl.com/tightsdirekte?allerID=1202604264\"><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: Megasalg hos Tights.no\" alt=\"Image: Megasalg hos Tights.no\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81274054.jpg?imageId=81274054&amp;x=0.000000&amp;y=9.437387&amp;cropw=100.000000&amp;croph=80.036298&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Megasalg hos</span><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">Tights.no</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=\"Dødsvinter: - Lang og voldsom\" href=\"https://www.dagbladet.no/nyheter/dodsvinter-lang-og-voldsom/81329135\"><figure class=\"x__sc-1an7vu1-0 qUoPe\"><picture><img data-defer=\"view\" title=\"Image: Dødsvinter: - Lang og voldsom\" alt=\"Image: Dødsvinter: - Lang og voldsom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81329559&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=425&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bkgkdp title dynamic-sizing\">Dødsvinter:</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">- Lang og voldsom</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=\"Nedslående beskjed\" href=\"https://www.dagbladet.no/sport/nedslaende-beskjed/81345914\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Nedslående beskjed\" alt=\"Image: Nedslående beskjed\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345919&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=17.857142857143&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 gNDiBf title dynamic-sizing\">Nedslående</span><span class=\"x__pt8tzk-0 bSlVPf title dynamic-sizing\">beskjed</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=\"- Vi er dypt bekymret\" href=\"https://www.dagbladet.no/nyheter/vi-er-dypt-bekymret/81346442\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Vi er dypt bekymret\" alt=\"Image: - Vi er dypt bekymret\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81346449&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">- Vi er dypt</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">bekymret</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=\"Ordkrigen fortsetter\" href=\"https://www.dagbladet.no/sport/ordkrigen-fortsetter/81341319\"><figure class=\"x__sc-1an7vu1-0 cnEQEw\"><picture><img data-defer=\"view\" title=\"Image: Ordkrigen fortsetter\" alt=\"Image: Ordkrigen fortsetter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341377&amp;panow=42.166344294004&amp;panoh=21.700879765396&amp;panoy=6.4516129032258&amp;panox=28.239845261122&amp;heightx=40&amp;heightw=18.989898989899&amp;heighth=46.223564954683&amp;heighty=6.0422960725076&amp;width=402&amp;height=345&amp;compression=70\" 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\">Ordkrigen</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">fortsetter</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=\"Ellevill prislapp: - Jeg lærer aldri\" href=\"https://www.dagbladet.no/kjendis/ellevill-prislapp-jeg-laerer-aldri/81339665\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ellevill prislapp: - Jeg lærer aldri\" alt=\"Image: Ellevill prislapp: - Jeg lærer aldri\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339757&amp;panoh=51.449275362319&amp;panoy=8.695652173913&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">Ellevill prislapp:</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- Jeg lærer aldri</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=\"- Funnet død med pose over hodet\" href=\"https://www.dagbladet.no/nyheter/funnet-dod-med-pose-over-hodet/81342518\"><figure class=\"x__sc-1an7vu1-0 gFiTCV\"><picture><img data-defer=\"view\" title=\"Image: - Funnet død med pose over hodet\" alt=\"Image: - Funnet død med pose over hodet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81340744&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=248&amp;compression=70\" 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\">- Funnet død med</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">pose over hodet</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=\"«Jakten»-par skilles\" href=\"https://www.dagbladet.no/kjendis/jakten-par-skilles/81340586\"><figure class=\"x__sc-1an7vu1-0 eXBGtj\"><picture><img data-defer=\"view\" title=\"Image: «Jakten»-par skilles\" alt=\"Image: «Jakten»-par skilles\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81340648&amp;panox=18.2156133829&amp;panoy=3.9325842696629&amp;panow=78.686492936803&amp;panoh=40.823969662921&amp;heightw=41.106128251121&amp;heighty=0&amp;heightx=34.529147982063&amp;heighth=99.77628590604&amp;width=402&amp;height=235&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">«Jakten»-par</span><span class=\"x__pt8tzk-0 eQgupK title dynamic-sizing\">skilles</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=\"- Jeg tjente mer penger enn ham\" href=\"https://www.dagbladet.no/kjendis/jeg-tjente-mer-penger-enn-ham/81309172\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Jeg tjente mer penger enn ham\" alt=\"Image: - Jeg tjente mer penger enn ham\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335652&amp;panoy=15.969581749049&amp;panox=0&amp;panow=100&amp;panoh=26.996197718631&amp;heightx=19.178082191781&amp;heightw=61.643835616438&amp;heighth=81.21546961326&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 ftetSQ title dynamic-sizing\">- Jeg tjente mer</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">penger enn ham</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Seks populære elsykler: - Velg denne!\" href=\"https://www.dagbladet.no/tema/seks-populaere-elsykler-velg-denne/81090828\"><figure class=\"x__sc-1an7vu1-0 jUYClY\"><picture><img data-defer=\"view\" title=\"Image: Seks populære elsykler: - Velg denne!\" alt=\"Image: Seks populære elsykler: - Velg denne!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81286379&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=173&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Seks populære</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">elsykler: - Velg denne!</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russisk missil-skandale i Østersjøen\" href=\"https://www.dagbladet.no/video/russisk-missil-skandale-i-ostersjoen/fJ0HGbqF\"><figure class=\"x__sc-1an7vu1-0 idKCHs\"><picture><img data-defer=\"view\" title=\"Image: Russisk missil-skandale i Østersjøen\" alt=\"Image: Russisk missil-skandale i Østersjøen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/fJ0HGbqF-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 kmxpNq title dynamic-sizing\">Russisk missil-skandale</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">i Østersjøen</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=\"Ugjenkjennelig\" href=\"https://www.dagbladet.no/kjendis/ugjenkjennelig/81341651\"><figure class=\"x__sc-1an7vu1-0 kbQZSd\"><picture><img data-defer=\"view\" title=\"Image: Ugjenkjennelig\" alt=\"Image: Ugjenkjennelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341702&amp;panoh=22.851152830189&amp;panoy=6.2893081761006&amp;panox=0&amp;panow=99.842766981132&amp;heightw=92.592591919192&amp;heighty=0&amp;heightx=0&amp;heighth=99.77628590604&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 LzBnW title dynamic-sizing\">Ugjenkjennelig</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=\"Reagerer: - Rapporter det\" href=\"https://www.dagbladet.no/kjendis/reagerer-rapporter-det/81342902\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Rapporter det\" alt=\"Image: Reagerer: - Rapporter det\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342917&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panoy=4.2553191489362&amp;heightw=41.106128251121&amp;heighty=0.22371409395974&amp;heightx=56.95067264574&amp;heighth=99.77628590604&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 jfcAvK title dynamic-sizing\">Reagerer:</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">- Rapporter det</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=\"- Kan vi bare gi henne en sjanse?\" href=\"https://www.dagbladet.no/kjendis/kan-vi-bare-gi-henne-en-sjanse/81343543\"><figure class=\"x__sc-1an7vu1-0 jcwGZQ\"><picture><img data-defer=\"view\" title=\"Image: - Kan vi bare gi henne en sjanse?\" alt=\"Image: - Kan vi bare gi henne en sjanse?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343430&amp;panow=100&amp;panoh=22.977346278317&amp;panoy=9.7087378640777&amp;panox=0&amp;heighth=52.127659574468&amp;heightw=47.120418848168&amp;heighty=3.1914893617021&amp;heightx=28.795811518325&amp;width=485&amp;height=411&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">- Kan vi bare gi</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">henne en sjanse?</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=\"- Det er ulovlig\" href=\"https://www.dagbladet.no/nyheter/det-er-ulovlig/81346215\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Det er ulovlig\" alt=\"Image: - Det er ulovlig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81346262&amp;panoh=50.714285714286&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kmfDed title dynamic-sizing\">- Det er</span><span class=\"x__pt8tzk-0 eCHIew title dynamic-sizing\">ulovlig</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=\"– Seks av syv spenn ødelagt\" href=\"https://www.dagbladet.no/video/-seks-av-syv-spenn-odelagt/nBm27GIO\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: – Seks av syv spenn ødelagt\" alt=\"Image: – Seks av syv spenn ødelagt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/nBm27GIO-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">– Seks av syv</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">spenn ødelagt</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Quiz uke 18: Simens ti kjappe!\" href=\"https://www.dagbladet.no/sport/quiz-uke-18-simens-ti-kjappe/81343884\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Quiz uke 18: Simens ti kjappe!\" alt=\"Image: Quiz uke 18: Simens ti kjappe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81056783&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Quiz uke 18:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Simens ti kjappe!</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Innrømmer: - Kysset en annen\" href=\"https://www.dagbladet.no/kjendis/innrommer-kysset-en-annen/81338858\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Innrømmer: - Kysset en annen\" alt=\"Image: Innrømmer: - Kysset en annen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338918&amp;panoy=14.761904761905&amp;panox=0&amp;panow=100&amp;panoh=33.809523809524&amp;heighty=0&amp;heightw=59.602649006623&amp;heighth=97.350993377483&amp;heightx=17.218543046358&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gNDiBf title dynamic-sizing\">Innrømmer:</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">- Kysset en annen</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Møtt av skrekksyn: - Ikke høysesong\" href=\"https://www.dagbladet.no/nyheter/mott-av-skrekksyn-ikke-hoysesong/81342657\"><figure class=\"x__sc-1an7vu1-0 htBhCB\"><picture><img data-defer=\"view\" title=\"Image: Møtt av skrekksyn: - Ikke høysesong\" alt=\"Image: Møtt av skrekksyn: - Ikke høysesong\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343036&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=359&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Møtt av skrekksyn:</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">- Ikke høysesong</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=\"- Bør stille oss spørsmålet \" href=\"https://www.dagbladet.no/nyheter/bor-stille-oss-sporsmalet/81344170\"><figure class=\"x__sc-1an7vu1-0 hRlocb\"><picture><img data-defer=\"view\" title=\"Image: - Bør stille oss spørsmålet \" alt=\"Image: - Bør stille oss spørsmålet \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81344230&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=231&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">- Bør stille</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">oss spørsmålet </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=\"Påvist i Norge\" href=\"https://www.dagbladet.no/nyheter/pavist-i-norge/81337338\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Påvist i Norge\" alt=\"Image: Påvist i Norge\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81337346&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightw=34.351145038168&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eQoVaS title dynamic-sizing\">Påvist i Norge</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=\"Russisk gassrørledning ødelagt\" href=\"https://www.dagbladet.no/video/russisk-gassrorledning-odelagt/oVX5OQgJ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russisk gassrørledning ødelagt\" alt=\"Image: Russisk gassrørledning ødelagt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/oVX5OQgJ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inhdgd title dynamic-sizing\">Russisk</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">gassrørledning</span><span class=\"x__pt8tzk-0 kpDSmG title dynamic-sizing\">ødelagt</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=\"Jess Erics metode: Ned 2 kilo i uka\" href=\"https://www.dagbladet.no/tema/jess-erics-metode-ned-2-kilo-i-uka/81279371\"><figure class=\"x__sc-1an7vu1-0 irXEZL\"><picture><img data-defer=\"view\" title=\"Image: Jess Erics metode: Ned 2 kilo i uka\" alt=\"Image: Jess Erics metode: Ned 2 kilo i uka\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81287443&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightw=13.740458015267&amp;heighth=100&amp;heightx=44.815572519084&amp;width=320&amp;height=308&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Jess Erics metode:</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Ned 2 kilo i uka</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=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ikke en krone for mye\" href=\"https://www.dagbladet.no/meninger/ikke-en-krone-for-mye/81339112\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ikke en krone for mye\" alt=\"Image: Ikke en krone for mye\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81336008&amp;panow=100.19047619048&amp;panoh=51.714285714286&amp;panoy=15.714285714286&amp;panox=0.19047619047619&amp;heightx=28.054298642534&amp;heighty=0.27210884353742&amp;heightw=40.904977375566&amp;heighth=100.27210884354&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Ikke en</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">krone for mye</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=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Forsiktige smil i landet gud glemte\" href=\"https://www.dagbladet.no/meninger/forsiktige-smil-i-landet-gud-glemte/81327885\"><figure class=\"x__sc-1an7vu1-0 gQoIpx\"><picture><img data-defer=\"view\" title=\"Image: Forsiktige smil i landet gud glemte\" alt=\"Image: Forsiktige smil i landet gud glemte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339978&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=336&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Forsiktige smil i</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">landet gud glemte</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=\"Nordmann tatt for hjemme-kastrering\" href=\"https://www.dagbladet.no/nyheter/nordmann-tatt-for-hjemme-kastrering/81343616\"><figure class=\"x__sc-1an7vu1-0 hBxfWp\"><picture><img data-defer=\"view\" title=\"Image: Nordmann tatt for hjemme-kastrering\" alt=\"Image: Nordmann tatt for hjemme-kastrering\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345090&amp;panow=100&amp;panoh=63.963963963964&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=46.953405017921&amp;heightw=32.258064516129&amp;heighth=100&amp;width=402&amp;height=417&amp;compression=70\" 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\">Nordmann tatt for</span><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">hjemme-kastrering</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=\"Over 30 graders forskjell\" href=\"https://www.dagbladet.no/nyheter/over-30-graders-forskjell/81346702\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Over 30 graders forskjell\" alt=\"Image: Over 30 graders forskjell\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81347044&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=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">Over 30 graders</span><span class=\"x__pt8tzk-0 iliEgZ title dynamic-sizing\">forskjell</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=\"Ekspertene advarer: Nye pensjonsfeller\" href=\"https://www.dagbladet.no/tema/ekspertene-advarer-nye-pensjonsfeller/81147536\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Ekspertene advarer: Nye pensjonsfeller\" alt=\"Image: Ekspertene advarer: Nye pensjonsfeller\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81154324&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=164&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Ekspertene advarer:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Nye pensjonsfeller</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=\"Metoden tar knekken på dem\" href=\"https://www.dagbladet.no/video/metoden-tar-knekken-pa-dem/8wPzlXgK\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Metoden tar knekken på dem\" alt=\"Image: Metoden tar knekken på dem\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/8wPzlXgK-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Metoden tar</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">knekken på dem</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=\"Gikk helt galt: - Var splitter ny!\" href=\"https://www.dagbladet.no/nyheter/gikk-helt-galt-var-splitter-ny/81339280\"><figure class=\"x__sc-1an7vu1-0 dAPHKR\"><picture><img data-defer=\"view\" title=\"Image: Gikk helt galt: - Var splitter ny!\" alt=\"Image: Gikk helt galt: - Var splitter ny!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339290&amp;panoy=29.136690647482&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=25.459633093525&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=286&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">Gikk helt galt:</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- Var splitter ny!</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 Gjerts taushet\" href=\"https://www.dagbladet.no/sport/bekrefter-gjerts-taushet/81339460\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter Gjerts taushet\" alt=\"Image: Bekrefter Gjerts taushet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339785&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 ctWqNs title dynamic-sizing\">Bekrefter</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">Gjerts taushet</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=\"Sjokkbilder fra Iran - utestenges\" href=\"https://www.dagbladet.no/video/sjokkbilder-fra-iran-utestenges/gE1GnBhm\"><figure class=\"x__sc-1an7vu1-0 jTuAlm\"><picture><img data-defer=\"view\" title=\"Image: Sjokkbilder fra Iran - utestenges\" alt=\"Image: Sjokkbilder fra Iran - utestenges\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/gE1GnBhm-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\">Sjokkbilder fra</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Iran - utestenges</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=\"Sissel: Ett grep - 10 kilo forsvant!\" href=\"https://www.dagbladet.no/tema/sissel-ett-grep-10-kilo-forsvant/81152733\"><figure class=\"x__sc-1an7vu1-0 eIlDNY\"><picture><img data-defer=\"view\" title=\"Image: Sissel: Ett grep - 10 kilo forsvant!\" alt=\"Image: Sissel: Ett grep - 10 kilo forsvant!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81155820&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=165&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">Sissel: Ett grep -</span><span class=\"x__pt8tzk-0 ihkPAv title dynamic-sizing\">10 kilo forsvant!</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=\"Hylles\" href=\"https://www.dagbladet.no/sport/hylles/81337136\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Hylles\" alt=\"Image: Hylles\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81337322&amp;panoh=44.654088050314&amp;panoy=17.610062893082&amp;panox=0&amp;panow=100&amp;heightx=26.288659793814&amp;heightw=46.39175257732&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 bBNPyh title dynamic-sizing\">Hylles</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=\"Nektet å forlate ektemannen\" href=\"https://www.dagbladet.no/nyheter/nektet-a-forlate-ektemannen/81338366\"><figure class=\"x__sc-1an7vu1-0 hPMFKU\"><picture><img data-defer=\"view\" title=\"Image: Nektet å forlate ektemannen\" alt=\"Image: Nektet å forlate ektemannen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338673&amp;panoy=31.178707224335&amp;panow=100&amp;panoh=26.996197718631&amp;panox=0&amp;heighty=12.254901960784&amp;heightx=32.121212121212&amp;heightw=54.545454545455&amp;heighth=72.058823529412&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 lplqa-d title dynamic-sizing\">Nektet å forlate</span><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">ektemannen</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=\"Atopisk eksem kobles til alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/studie-kobler-atopisk-eksem-til-kronisk-sykdom/81334619\"><figure class=\"x__sc-1an7vu1-0 dZwFXb\"><picture><img data-defer=\"view\" title=\"Image: Atopisk eksem kobles til alvorlig sykdom\" alt=\"Image: Atopisk eksem kobles til alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80197278&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=182&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Atopisk eksem kobles</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">til alvorlig sykdom</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=\"- Livsfarlig\" href=\"https://www.dagbladet.no/video/-livsfarlig/FWV0OCuM\"><figure class=\"x__sc-1an7vu1-0 dZwFXb\"><picture><img data-defer=\"view\" title=\"Image: - Livsfarlig\" alt=\"Image: - Livsfarlig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/FWV0OCuM-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 jIyTDK title dynamic-sizing\">- Livsfarlig</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=\"Skjult kamera plassert i forsvarets lokaler\" href=\"https://www.dagbladet.no/video/skjult-kamera-plassert-i-forsvarets-lokaler/6tY6LmiT\"><figure class=\"x__sc-1an7vu1-0 jyPXHD\"><picture><img data-defer=\"view\" title=\"Image: Skjult kamera plassert i forsvarets lokaler\" alt=\"Image: Skjult kamera plassert i forsvarets lokaler\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/6tY6LmiT-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\">Skjult kamera plassert</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">i forsvarets lokaler</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=\"Refluks-medisin: Ekspertenes nye advarsel\" href=\"https://www.dagbladet.no/tema/refluks-medisin-ekspertenes-nye-advarsel/81229148\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Refluks-medisin: Ekspertenes nye advarsel\" alt=\"Image: Refluks-medisin: Ekspertenes nye advarsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=78057281&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Refluks-medisin:</span><span class=\"x__pt8tzk-0 dXa-DVQ title dynamic-sizing\">Ekspertenes</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">nye advarsel</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=\"Politiet vil heve mystisk fryseboks\" href=\"https://www.dagbladet.no/nyheter/politiet-vil-heve-mystisk-fryseboks/81343137\"><figure class=\"x__sc-1an7vu1-0 ioOUcG\"><picture><img data-defer=\"view\" title=\"Image: Politiet vil heve mystisk fryseboks\" alt=\"Image: Politiet vil heve mystisk fryseboks\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343159&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=294&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">Politiet vil heve</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">mystisk fryseboks</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=\"- Sa de skulle drepe ham\" href=\"https://www.dagbladet.no/nyheter/sa-de-skulle-drepe-ham/81342583\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Sa de skulle drepe ham\" alt=\"Image: - Sa de skulle drepe ham\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342612&amp;panoh=51.034482758621&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=39.301310043668&amp;heightw=41.048034934498&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 hrVcDN title dynamic-sizing\">- Sa de skulle</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">drepe ham</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=\"Ett grep: Sixpack i superfart\" href=\"https://www.dagbladet.no/tema/ett-grep-sixpacki-superfart/81143064\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ett grep: Sixpack i superfart\" alt=\"Image: Ett grep: Sixpack i superfart\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76024151&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">Ett grep: Sixpack</span><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">i superfart</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=\"Absurde bilder fra slagmarken\" href=\"https://www.dagbladet.no/video/absurde-bilder-fra-slagmarken/tnjArkKd\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Absurde bilder fra slagmarken\" alt=\"Image: Absurde bilder fra slagmarken\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/tnjArkKd-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\">Absurde bilder</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">fra slagmarken</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 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=\"Snikfilmet på do: Lekket på nett\" href=\"https://www.dagbladet.no/nyheter/snikfilmet-pa-do-lekket-pa-nett/81342675\"><figure class=\"x__sc-1an7vu1-0 kzGLIr\"><picture><img data-defer=\"view\" title=\"Image: Snikfilmet på do: Lekket på nett\" alt=\"Image: Snikfilmet på do: Lekket på nett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343262&amp;panow=100&amp;panoh=84.69696969697&amp;panox=0&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=84.69696969697&amp;width=402&amp;height=298&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">Snikfilmet på do:</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">Lekket på nett</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=\"USA: Brøt forbud mot kjemiske våpen\" href=\"https://www.dagbladet.no/nyheter/usa-brot-forbud-mot-kjemiske-vapen/81341223\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: USA: Brøt forbud mot kjemiske våpen\" alt=\"Image: USA: Brøt forbud mot kjemiske våpen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341229&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">USA: Brøt forbud</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">mot kjemiske våpen</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=\"Fanges på film\" href=\"https://www.dagbladet.no/video/fanges-pa-film/JHKLWAVS\"><figure class=\"x__sc-1an7vu1-0 lcWYHB\"><picture><img data-defer=\"view\" title=\"Image: Fanges på film\" alt=\"Image: Fanges på film\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/JHKLWAVS-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\">Fanges på film</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=\"Psykopater: - Mange går under radaren\" href=\"https://www.dagbladet.no/tema/hoytid-for-psykopatene-avslor-dem/81161714\"><figure class=\"x__sc-1an7vu1-0 gmpxUf\"><picture><img data-defer=\"view\" title=\"Image: Psykopater: - Mange går under radaren\" alt=\"Image: Psykopater: - Mange går under radaren\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=78904412&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=178&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 ggUSon title dynamic-sizing\">Psykopater: - Mange</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">går under radaren</span></h3></header></a></article><div id=\"apos-medium-rectangle8\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gir seg i politikken\" href=\"https://www.dagbladet.no/nyheter/gir-seg-i-politikken/81346488\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Gir seg i politikken\" alt=\"Image: Gir seg i politikken\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81346499&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=17.857142857143&amp;panox=0&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 gbeFJE title dynamic-sizing\">Gir seg i</span><span class=\"x__pt8tzk-0 fZJFvq title dynamic-sizing\">politikken</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Nå eller aldri\" href=\"https://www.dagbladet.no/nyheter/na-eller-aldri/81341899\"><figure class=\"x__sc-1an7vu1-0 fwaYEb\"><picture><img data-defer=\"view\" title=\"Image: - Nå eller aldri\" alt=\"Image: - Nå eller aldri\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341904&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=402&amp;height=498&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">- Nå eller aldri</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=\"Ny astmamedisin: 70 prosent færre anfall\" href=\"https://www.dagbladet.no/tema/ny-astmamedisin70-prosent-faerre-anfall/81108717\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ny astmamedisin: 70 prosent færre anfall\" alt=\"Image: Ny astmamedisin: 70 prosent færre anfall\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81141573&amp;panox=0.18957345971564&amp;panow=100.18957345972&amp;panoh=47.94701986755&amp;panoy=13.907284768212&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 kwLuaB title dynamic-sizing\">Ny astmamedisin: 70</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">prosent færre anfall</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=\"Turistene får sjokk\" href=\"https://www.dagbladet.no/video/turistene-far-sjokk/l9wjU8LV\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Turistene får sjokk\" alt=\"Image: Turistene får sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/l9wjU8LV-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 fTAjeM title dynamic-sizing\">Turistene</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">får sjokk</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=\"Legger opp etter dette\" href=\"https://www.dagbladet.no/video/legger-opp-etter-dette/1iH4rxuP\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Legger opp etter dette\" alt=\"Image: Legger opp etter dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/1iH4rxuP-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 bWSnVS title dynamic-sizing\">Legger opp</span><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">etter dette</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Påskequiz 22. mars: Simens ti kjappe!\" href=\"https://www.dagbladet.no/nyheter/paskequiz-22-mars-simens-ti-kjappe-1/81160610\"><figure class=\"x__sc-1an7vu1-0 hjJzLP\"><picture><img data-defer=\"view\" title=\"Image: Påskequiz 22. mars: Simens ti kjappe!\" alt=\"Image: Påskequiz 22. mars: Simens ti kjappe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81056783&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=216&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Påskequiz 22. mars:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Simens ti kjappe!</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=\"Fibromyalgi: Tre spørsmål avgjør uføretrygd\" href=\"https://www.dagbladet.no/tema/fibromyalgi-tre-sporsmal-avgjor-uforetrygd/81334492\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Fibromyalgi: Tre spørsmål avgjør uføretrygd\" alt=\"Image: Fibromyalgi: Tre spørsmål avgjør uføretrygd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345015&amp;panox=0.10683749999999&amp;panow=100.1068375&amp;panoh=60.873694017094&amp;panoy=23.931623931624&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 frzFun title dynamic-sizing\">Fibromyalgi: Tre</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">spørsmål avgjør</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">uføretrygd</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Reaksjonene hagler\" href=\"https://www.dagbladet.no/video/reaksjonene-hagler/nEcVysH5\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Reaksjonene hagler\" alt=\"Image: Reaksjonene hagler\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/nEcVysH5-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 cFtCN title dynamic-sizing\">Reaksjonene hagler</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=\"Plutselig kommer kjempen\" href=\"https://www.dagbladet.no/video/plutselig-kommer-kjempen/UZEPJlNX\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Plutselig kommer kjempen\" alt=\"Image: Plutselig kommer kjempen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/UZEPJlNX-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">Plutselig</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">kommer kjempen</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=\"Unngå uførefellene - avgjørende grep\" href=\"https://www.dagbladet.no/tema/wenches-metode-unngikk-uforefellene/81149046\"><figure class=\"x__sc-1an7vu1-0 hygKBp\"><picture><img data-defer=\"view\" title=\"Image: Unngå uførefellene - avgjørende grep\" alt=\"Image: Unngå uførefellene - avgjørende grep\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=79184685&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0.34965034965035&amp;heightx=23.255813953488&amp;heightw=40.697674418605&amp;heighth=100.34965034965&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 zWscE title dynamic-sizing\">Unngå uførefellene</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">- avgjørende grep</span></h3></header></a></article><div id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tatt ut av produksjonen: - Fikk panikk\" href=\"https://www.dagbladet.no/video/tatt-ut-av-produksjonen-fikk-panikk/UXNNfjZr\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Tatt ut av produksjonen: - Fikk panikk\" alt=\"Image: Tatt ut av produksjonen: - Fikk panikk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/UXNNfjZr-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\">Tatt ut av</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">produksjonen:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">- Fikk panikk</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=\"Deler metoden: Kiloene raste\" href=\"https://www.dagbladet.no/tema/deler-metoden-kiloene-raste/81155404\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Deler metoden: Kiloene raste\" alt=\"Image: Deler metoden: Kiloene raste\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81173147&amp;panow=55.555555733333&amp;panoh=78.388279120879&amp;panoy=7.6923076923077&amp;panox=21.866666666667&amp;heighty=1.25&amp;heightx=51.007751937984&amp;heightw=13.850129302326&amp;heighth=91.45833375&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Deler metoden:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Kiloene raste</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=\"Oslo: Skutt på åpen gate\" href=\"https://www.dagbladet.no/video/oslo-skutt-pa-apen-gate/BSIUH2PN\"><figure class=\"x__sc-1an7vu1-0 iEicaO\"><picture><img data-defer=\"view\" title=\"Image: Oslo: Skutt på åpen gate\" alt=\"Image: Oslo: Skutt på åpen gate\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/BSIUH2PN-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 bWSnVS title dynamic-sizing\">Oslo: Skutt</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">på åpen gate</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=\"«Amanda» var utro: Unnskyldningene hun serverte \" href=\"https://www.dagbladet.no/tema/amanda-var-utro-unnskyldningene-hun-serverte/81149452\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: «Amanda» var utro: Unnskyldningene hun serverte \" alt=\"Image: «Amanda» var utro: Unnskyldningene hun serverte \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81160005&amp;panoy=13.138686131387&amp;panox=0&amp;panow=99.759615384615&amp;panoh=51.459854014599&amp;heighty=0.3448275862069&amp;heightw=40.227272727273&amp;heighth=100.34482758621&amp;heightx=15.909090909091&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">«Amanda» var utro:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Unnskyldningene</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">hun serverte </span></h3></header></a></article><div 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>"]