["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .kRxauv.kRxauv.kRxauv.kRxauv{height:0;padding-bottom:73.19%;}/*!sc*/ .iYLNuD.iYLNuD.iYLNuD.iYLNuD{height:0;padding-bottom:56.7%;}/*!sc*/ .jqAWdU.jqAWdU.jqAWdU.jqAWdU{height:0;padding-bottom:73.43%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .cduubc.cduubc.cduubc.cduubc{height:0;padding-bottom:102.48%;}/*!sc*/ .kvbyOp.kvbyOp.kvbyOp.kvbyOp{height:0;padding-bottom:75.37%;}/*!sc*/ .ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .jLeHxJ.jLeHxJ.jLeHxJ.jLeHxJ{height:0;padding-bottom:76.7%;}/*!sc*/ .jvxxno.jvxxno.jvxxno.jvxxno{height:0;padding-bottom:108.2%;}/*!sc*/ .gzqAYE.gzqAYE.gzqAYE.gzqAYE{height:0;padding-bottom:66.87%;}/*!sc*/ .kbQZSd.kbQZSd.kbQZSd.kbQZSd{height:0;padding-bottom:71.95%;}/*!sc*/ .ioDOlL.ioDOlL.ioDOlL.ioDOlL{height:0;padding-bottom:51.95%;}/*!sc*/ .cjSQRT.cjSQRT.cjSQRT.cjSQRT{height:0;padding-bottom:81.09%;}/*!sc*/ .dvwkoI.dvwkoI.dvwkoI.dvwkoI{height:0;padding-bottom:88.3%;}/*!sc*/ .ejHyWU.ejHyWU.ejHyWU.ejHyWU{height:0;padding-bottom:63.75%;}/*!sc*/ .hlqDzP.hlqDzP.hlqDzP.hlqDzP{height:0;padding-bottom:54.72%;}/*!sc*/ .gpFUbf.gpFUbf.gpFUbf.gpFUbf{height:0;padding-bottom:117.16%;}/*!sc*/ .gFiTCV.gFiTCV.gFiTCV.gFiTCV{height:0;padding-bottom:51.13%;}/*!sc*/ .jyFlEO.jyFlEO.jyFlEO.jyFlEO{height:0;padding-bottom:55.9%;}/*!sc*/ .gkSegO.gkSegO.gkSegO.gkSegO{height:0;padding-bottom:65.93%;}/*!sc*/ .jYZLUK.jYZLUK.jYZLUK.jYZLUK{height:0;padding-bottom:61.64%;}/*!sc*/ .bpchQk.bpchQk.bpchQk.bpchQk{height:0;padding-bottom:81.64%;}/*!sc*/ .iRrFGC.iRrFGC.iRrFGC.iRrFGC{height:0;padding-bottom:54.37%;}/*!sc*/ .hrRtCC.hrRtCC.hrRtCC.hrRtCC{height:0;padding-bottom:104.22%;}/*!sc*/ .jDKzJI.jDKzJI.jDKzJI.jDKzJI{height:0;padding-bottom:74.37%;}/*!sc*/ .gbGggw.gbGggw.gbGggw.gbGggw{height:0;padding-bottom:66.25%;}/*!sc*/ .bpwXh.bpwXh.bpwXh.bpwXh{height:0;padding-bottom:53.4%;}/*!sc*/ .enMUO.enMUO.enMUO.enMUO{height:0;padding-bottom:91.54%;}/*!sc*/ .ksIXeg.ksIXeg.ksIXeg.ksIXeg{height:0;padding-bottom:54.68%;}/*!sc*/ .juZrXb.juZrXb.juZrXb.juZrXb{height:0;padding-bottom:70.92%;}/*!sc*/ .dZwFXb.dZwFXb.dZwFXb.dZwFXb{height:0;padding-bottom:56.87%;}/*!sc*/ .jTuAlm.jTuAlm.jTuAlm.jTuAlm{height:0;padding-bottom:50.62%;}/*!sc*/ .fgEAoQ.fgEAoQ.fgEAoQ.fgEAoQ{height:0;padding-bottom:69.15%;}/*!sc*/ .gwQmTe.gwQmTe.gwQmTe.gwQmTe{height:0;padding-bottom:65.31%;}/*!sc*/ .foOzbz.foOzbz.foOzbz.foOzbz{height:0;padding-bottom:50.1%;}/*!sc*/ .cAHFIm.cAHFIm.cAHFIm.cAHFIm{height:0;padding-bottom:87.31%;}/*!sc*/ .iGTxZG.iGTxZG.iGTxZG.iGTxZG{height:0;padding-bottom:74.06%;}/*!sc*/ .SpJRa.SpJRa.SpJRa.SpJRa{height:0;padding-bottom:77.36%;}/*!sc*/ .ibyVuT.ibyVuT.ibyVuT.ibyVuT{height:0;padding-bottom:56.25%;}/*!sc*/ .iEicaO.iEicaO.iEicaO.iEicaO{height:0;padding-bottom:53.43%;}/*!sc*/ .hjCnKb.hjCnKb.hjCnKb.hjCnKb{height:0;padding-bottom:60%;}/*!sc*/ .jJDuNs.jJDuNs.jJDuNs.jJDuNs{height:0;padding-bottom:57.5%;}/*!sc*/ data-styled.g371[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,fnQDHb,kRxauv,iYLNuD,jqAWdU,kviAry,cduubc,kvbyOp,ejnyBo,jLeHxJ,jvxxno,gzqAYE,kbQZSd,ioDOlL,cjSQRT,dvwkoI,ejHyWU,hlqDzP,gpFUbf,gFiTCV,jyFlEO,gkSegO,jYZLUK,bpchQk,iRrFGC,hrRtCC,jDKzJI,gbGggw,bpwXh,enMUO,ksIXeg,juZrXb,dZwFXb,jTuAlm,fgEAoQ,gwQmTe,foOzbz,cAHFIm,iGTxZG,SpJRa,ibyVuT,iEicaO,hjCnKb,jJDuNs,\"}/*!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*/ .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*/ .jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:0.5em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .gyIQtO.gyIQtO.gyIQtO.gyIQtO{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gyIQtO.gyIQtO.gyIQtO.gyIQtO{font-size:2.7em!important;}}/*!sc*/ .cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:0.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:2em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .dJenrE.dJenrE.dJenrE.dJenrE{font-size:6.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.dJenrE.dJenrE.dJenrE.dJenrE{font-size:2.3em!important;}}/*!sc*/ .jijxuQ.jijxuQ.jijxuQ.jijxuQ{font-size:9.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jijxuQ.jijxuQ.jijxuQ.jijxuQ{font-size:3.2em!important;}}/*!sc*/ .jfhrCI.jfhrCI.jfhrCI.jfhrCI{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfhrCI.jfhrCI.jfhrCI.jfhrCI{font-size:1.2em!important;}}/*!sc*/ .lfBuL.lfBuL.lfBuL.lfBuL{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.lfBuL.lfBuL.lfBuL.lfBuL{font-size:1.3em!important;}}/*!sc*/ .jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:2.1em!important;}}/*!sc*/ .eEpMqg.eEpMqg.eEpMqg.eEpMqg{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.eEpMqg.eEpMqg.eEpMqg.eEpMqg{font-size:2.3em!important;}}/*!sc*/ .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*/ .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*/ .hRXaXr.hRXaXr.hRXaXr.hRXaXr{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.hRXaXr.hRXaXr.hRXaXr.hRXaXr{font-size:1.4em!important;}}/*!sc*/ .kYsbxS.kYsbxS.kYsbxS.kYsbxS{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kYsbxS.kYsbxS.kYsbxS.kYsbxS{font-size:1.2em!important;}}/*!sc*/ .bwzwBX.bwzwBX.bwzwBX.bwzwBX{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwzwBX.bwzwBX.bwzwBX.bwzwBX{font-size:1.8em!important;}}/*!sc*/ .dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:2em!important;}}/*!sc*/ .hbwikt.hbwikt.hbwikt.hbwikt{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.hbwikt.hbwikt.hbwikt.hbwikt{font-size:2.1em!important;}}/*!sc*/ .dbonoY.dbonoY.dbonoY.dbonoY{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.dbonoY.dbonoY.dbonoY.dbonoY{font-size:2em!important;}}/*!sc*/ .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*/ .beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:0.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .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*/ .cICKVW.cICKVW.cICKVW.cICKVW{font-size:10.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.cICKVW.cICKVW.cICKVW.cICKVW{font-size:3.8em!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*/ .hjGKKq.hjGKKq.hjGKKq.hjGKKq{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.hjGKKq.hjGKKq.hjGKKq.hjGKKq{font-size:2.3em!important;}}/*!sc*/ .cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:7em!important;}/*!sc*/ @media only screen and (max-width:640px){.cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:2.4em!important;}}/*!sc*/ .eYoKgk.eYoKgk.eYoKgk.eYoKgk{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.eYoKgk.eYoKgk.eYoKgk.eYoKgk{font-size:1.5em!important;}}/*!sc*/ .cKlSIC.cKlSIC.cKlSIC.cKlSIC{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cKlSIC.cKlSIC.cKlSIC.cKlSIC{font-size:1.3em!important;}}/*!sc*/ .bvXqXn.bvXqXn.bvXqXn.bvXqXn{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvXqXn.bvXqXn.bvXqXn.bvXqXn{font-size:1.4em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .emKkIi.emKkIi.emKkIi.emKkIi{font-size:10.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.emKkIi.emKkIi.emKkIi.emKkIi{font-size:3.7em!important;}}/*!sc*/ .dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:2.4em!important;}}/*!sc*/ .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*/ .gRLJwN.gRLJwN.gRLJwN.gRLJwN{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gRLJwN.gRLJwN.gRLJwN.gRLJwN{font-size:1.8em!important;}}/*!sc*/ .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*/ .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*/ .iVreMl.iVreMl.iVreMl.iVreMl{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.iVreMl.iVreMl.iVreMl.iVreMl{font-size:1.6em!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*/ .criDNb.criDNb.criDNb.criDNb{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.criDNb.criDNb.criDNb.criDNb{font-size:2em!important;}}/*!sc*/ .kdEriU.kdEriU.kdEriU.kdEriU{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kdEriU.kdEriU.kdEriU.kdEriU{font-size:1.5em!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*/ .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*/ .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*/ .ivnriz.ivnriz.ivnriz.ivnriz{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ivnriz.ivnriz.ivnriz.ivnriz{font-size:1.2em!important;}}/*!sc*/ .fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:1.2em!important;}}/*!sc*/ .hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:1.8em!important;}}/*!sc*/ .dA-Dohz.dA-Dohz.dA-Dohz.dA-Dohz{font-size:7.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.dA-Dohz.dA-Dohz.dA-Dohz.dA-Dohz{font-size:2.8em!important;}}/*!sc*/ .beQydf.beQydf.beQydf.beQydf{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.beQydf.beQydf.beQydf.beQydf{font-size:1.7em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .diUuRk.diUuRk.diUuRk.diUuRk{font-size:1.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.diUuRk.diUuRk.diUuRk.diUuRk{font-size:0.4em!important;}}/*!sc*/ .eJvLkS.eJvLkS.eJvLkS.eJvLkS{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.eJvLkS.eJvLkS.eJvLkS.eJvLkS{font-size:2em!important;}}/*!sc*/ .kuSqyf.kuSqyf.kuSqyf.kuSqyf{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kuSqyf.kuSqyf.kuSqyf.kuSqyf{font-size:1.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*/ .hpQSgl.hpQSgl.hpQSgl.hpQSgl{font-size:1.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.hpQSgl.hpQSgl.hpQSgl.hpQSgl{font-size:0.5em!important;}}/*!sc*/ data-styled.g372[id=\"x__pt8tzk-0\"]{content:\"fFAiTK,dfserP,jRIgeY,gPIxea,tqGkg,kyzRFP,iXjdLY,ftetSQ,ctWqNs,hQxAYP,bWSnVS,iFlEmK,cyVXzf,eQoVaS,jiGVVj,gyIQtO,cnaKkM,bwGQrt,hrVcDN,jdcGMN,bxtuZJ,iYgBvA,jfvMWJ,frzFun,dJenrE,jijxuQ,jfhrCI,lfBuL,jJrnNf,eEpMqg,fNDhDy,iNHyie,hRXaXr,kYsbxS,bwzwBX,dWzMnA,hbwikt,dbonoY,Uccen,beDNpZ,dDKeDQ,epoJzD,jGSTdz,kVJNPR,hsPeia,gNDiBf,glOqqI,kNhGgX,dLwqhJ,inoUtg,cICKVW,gVRWAB,hjGKKq,cUXKOF,eYoKgk,cKlSIC,bvXqXn,zWscE,gjHDge,jEhvtw,jtCXvA,emKkIi,dQSCBR,jdgMzU,gRLJwN,ddbCJZ,hRdvzd,iVreMl,dyaAfc,criDNb,kdEriU,fZJFvq,LzBnW,cFtCN,ivnriz,fIeyCx,hPDIHE,dA-Dohz,beQydf,gLHLEv,bkgkdp,fTAjeM,ihkPAv,diUuRk,eJvLkS,kuSqyf,dPoeFo,hpQSgl,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div id=\"apos-netboard3\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Putins siste advarsel\" href=\"https://www.dagbladet.no/video/-putins-siste-advarsel/cv7eoP10\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Putins siste advarsel\" alt=\"Image: - Putins siste advarsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/cv7eoP10-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">- Putins</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">siste advarsel</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Rasmus&#x27; magefett-formel: Kiloene raser\" href=\"https://www.dagbladet.no/tema/rasmus-magefett-formel-kiloene-raser/81394145\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Rasmus&#x27; magefett-formel: Kiloene raser\" alt=\"Image: Rasmus&#x27; magefett-formel: Kiloene raser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81402423&amp;panoy=0&amp;panox=8.0321285140562&amp;panow=87.550200803213&amp;panoh=100&amp;heighty=0&amp;heightx=40.661478599222&amp;heightw=18.287937743191&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jRIgeY title dynamic-sizing\">Rasmus&#x27; magefett-formel:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Kiloene raser</span></h3></header></a></article></div></div></div><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=\"- Drar henne inn i porno\" href=\"https://www.dagbladet.no/kjendis/drar-henne-inn-i-porno/81418973\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Drar henne inn i porno\" alt=\"Image: - Drar henne inn i porno\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418981&amp;panoy=25.977653631285&amp;panow=88.563458577406&amp;panoh=20.297951396648&amp;panox=0&amp;heighty=25.377643504532&amp;heightx=17.43119266055&amp;heightw=42.048929357798&amp;heighth=44.91440060423&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 tqGkg title dynamic-sizing\">- Drar henne</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">inn i porno</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=\"Knuser Brenna\" href=\"https://www.dagbladet.no/nyheter/knuser-brenna/81403093\"><figure class=\"x__sc-1an7vu1-0 kRxauv\"><picture><img data-defer=\"view\" title=\"Image: Knuser Brenna\" alt=\"Image: Knuser Brenna\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81413507&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0.21505419354839&amp;heightw=46.440129126214&amp;heighth=99.784945806452&amp;heightx=31.553398058252&amp;width=485&amp;height=355&amp;compression=70\" 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\">Knuser Brenna</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=\"Ut mot eksen: - Lei meg\" href=\"https://www.dagbladet.no/sport/ut-mot-eksen-lei-meg/81419932\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ut mot eksen: - Lei meg\" alt=\"Image: Ut mot eksen: - Lei meg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419947&amp;panoh=33.333333333333&amp;panoy=15.962441314554&amp;panox=0&amp;panow=100&amp;heightx=6.2068965517241&amp;heightw=62.068965517241&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 ftetSQ title dynamic-sizing\">Ut mot eksen:</span><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">- Lei meg</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"«Ødelegger norske bunaden»\" href=\"https://www.dagbladet.no/kjendis/odelegger-norske-bunaden/81419842\"><figure class=\"x__sc-1an7vu1-0 iYLNuD\"><picture><img data-defer=\"view\" title=\"Image: «Ødelegger norske bunaden»\" alt=\"Image: «Ødelegger norske bunaden»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81420341&amp;panox=8.6206896551724&amp;panoy=9.8976109215017&amp;panow=91.235631896552&amp;panoh=24.800909897611&amp;heightx=35.353535353535&amp;heightw=30.864197306397&amp;heighth=39.857015013405&amp;heighty=2.6809651474531&amp;width=485&amp;height=275&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">«Ødelegger</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">norske bunaden»</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=\"Venninnas uro: Den siste samtalen\" href=\"https://www.dagbladet.no/nyheter/venninnas-uro-den-siste-samtalen/81321361\"><figure class=\"x__sc-1an7vu1-0 jqAWdU\"><picture><img data-defer=\"view\" title=\"Image: Venninnas uro: Den siste samtalen\" alt=\"Image: Venninnas uro: Den siste samtalen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76828491&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=235&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Venninnas uro:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Den siste samtalen</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Politiet ber om tips\" href=\"https://www.dagbladet.no/video/her-gar-det-galt/JcevLD4G\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Politiet ber om tips\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81404867.jpg?imageId=81404867&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/14/4cedd9e1-9699-48ff-84fa-89a4108c4f33/gif_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/14/4cedd9e1-9699-48ff-84fa-89a4108c4f33/gif_2.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eQoVaS title dynamic-sizing\">Politiet</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">ber om tips</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=\"- Var forelsket i en annen\" href=\"https://www.dagbladet.no/kjendis/var-forelsket-i-en-annen/81413139\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Var forelsket i en annen\" alt=\"Image: - Var forelsket i en annen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81412977&amp;panoy=11.864406779661&amp;panow=100&amp;panoh=60.169491525424&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 tqGkg title dynamic-sizing\">- Var forelsket</span><span class=\"x__pt8tzk-0 gyIQtO title dynamic-sizing\">i 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åtte ta farskapstest - drepte sønnen (4 md.)\" href=\"https://www.dagbladet.no/nyheter/matte-ta-farskapstest-drepte-sonnen-4-md/81405393\"><figure class=\"x__sc-1an7vu1-0 cduubc\"><picture><img data-defer=\"view\" title=\"Image: Måtte ta farskapstest - drepte sønnen (4 md.)\" alt=\"Image: Måtte ta farskapstest - drepte sønnen (4 md.)\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81407272&amp;panox=0.15723301886793&amp;panoy=14.184397163121&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heightx=18.834080717489&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heighty=0&amp;width=402&amp;height=412&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cnaKkM title dynamic-sizing\">Måtte ta farskapstest</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">- drepte sønnen (4 md.)</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=\"Store problemer for Telenor\" href=\"https://www.dagbladet.no/nyheter/store-problemer-for-telenor/81421433\"><figure class=\"x__sc-1an7vu1-0 kvbyOp\"><picture><img data-defer=\"view\" title=\"Image: Store problemer for Telenor\" alt=\"Image: Store problemer for Telenor\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81421315&amp;panow=100&amp;panox=0&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=303&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Store problemer</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">for Telenor</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=\"Raser dagen derpå: - Ikke vakkert\" href=\"https://www.dagbladet.no/nyheter/raser-dagen-derpa-ikke-vakkert/81420431\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Raser dagen derpå: - Ikke vakkert\" alt=\"Image: Raser dagen derpå: - Ikke vakkert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81420449&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Raser dagen derpå:</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">- Ikke vakkert</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nytt rosacea-grep vekker oppsikt\" href=\"https://www.dagbladet.no/tema/nytt-rosacea-grep-vekker-oppsikt/81342868\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Nytt rosacea-grep vekker oppsikt\" alt=\"Image: Nytt rosacea-grep vekker oppsikt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81344356&amp;panoy=16.129032258065&amp;panow=100&amp;panoh=45.161290322581&amp;panox=0&amp;heighty=0&amp;heightx=4.7120418848168&amp;heightw=46.073298429319&amp;heighth=100&amp;width=320&amp;height=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 iYgBvA title dynamic-sizing\">Nytt rosacea-grep</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">vekker oppsikt</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Har hyrdestund foran personalet\" href=\"https://www.dagbladet.no/video/har-hyrdestund-foran-personalet/NdHCMDuu\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Har hyrdestund foran personalet\" alt=\"Image: Har hyrdestund foran personalet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/NdHCMDuu-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Har hyrdestund</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">foran personalet</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=\"Disse skal stå bak\" href=\"https://www.dagbladet.no/nyheter/disse-skal-sta-bak/81420392\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Disse skal stå bak\" alt=\"Image: Disse skal stå bak\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81420524&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dJenrE title dynamic-sizing\">Disse skal</span><span class=\"x__pt8tzk-0 jijxuQ title dynamic-sizing\">stå bak</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=\"Oslo: Næringsbygg totalskadd i brann\" href=\"https://www.dagbladet.no/nyheter/oslo-naeringsbygg-totalskadd-i-brann/81421133\"><figure class=\"x__sc-1an7vu1-0 jLeHxJ\"><picture><img data-defer=\"view\" title=\"Image: Oslo: Næringsbygg totalskadd i brann\" alt=\"Image: Oslo: Næringsbygg totalskadd i brann\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81421151&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=372&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfhrCI title dynamic-sizing\">Oslo: Næringsbygg</span><span class=\"x__pt8tzk-0 lfBuL title dynamic-sizing\">totalskadd i brann</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Folk trodde jeg skulle ta livet av meg\" href=\"https://www.dagbladet.no/nyheter/folk-trodde-jeg-skulle-ta-livet-av-meg/81393848\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Folk trodde jeg skulle ta livet av meg\" alt=\"Image: - Folk trodde jeg skulle ta livet av meg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81394123&amp;panoy=17.857142857143&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=5.421686746988&amp;heightx=39.516129032258&amp;heightw=36.290322580645&amp;heighth=88.55421686747&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jJrnNf title dynamic-sizing\">- Folk trodde</span><span class=\"x__pt8tzk-0 eEpMqg title dynamic-sizing\">jeg skulle ta</span><span class=\"x__pt8tzk-0 eEpMqg title dynamic-sizing\">livet av meg</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=\"Svarer på spekulasjonene\" href=\"https://www.dagbladet.no/kjendis/svarer-pa-spekulasjonene/81412578\"><figure class=\"x__sc-1an7vu1-0 jvxxno\"><picture><img data-defer=\"view\" title=\"Image: Svarer på spekulasjonene\" alt=\"Image: Svarer på spekulasjonene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81413628&amp;panox=0.22819052132701&amp;panoy=15.511551155116&amp;panow=99.771809478673&amp;panoh=23.603471287129&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=402&amp;height=435&amp;compression=70\" 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\">Svarer på</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">spekulasjonene</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=\"Metoden: - Lært meg å takle angsten\" href=\"https://www.dagbladet.no/tema/metoden-laert-meg-a-takle-angsten/81336535\"><figure class=\"x__sc-1an7vu1-0 gzqAYE\"><picture><img data-defer=\"view\" title=\"Image: Metoden: - Lært meg å takle angsten\" alt=\"Image: Metoden: - Lært meg å takle angsten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81350201&amp;panoy=8.9735922330097&amp;panox=0&amp;panow=100&amp;panoh=23.948220064725&amp;heighty=0&amp;heightx=11.650485436893&amp;heightw=87.162893203884&amp;heighth=99.847794520548&amp;width=320&amp;height=214&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Metoden: - Lært</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">meg å takle angsten</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russland: Flere skadd\" href=\"https://www.dagbladet.no/video/russland-flere-skadd/KBCP3BpB\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russland: Flere skadd\" alt=\"Image: Russland: Flere skadd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/KBCP3BpB-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hRXaXr title dynamic-sizing\">Russland:</span><span class=\"x__pt8tzk-0 kYsbxS title dynamic-sizing\">Flere skadd</span></h3></header></a></article><div id=\"apos-medium-rectangle-perz3\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle-perz3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle-perz3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Drama: - 40 har kollapset\" href=\"https://www.dagbladet.no/sport/drama-40-har-kollapset/81421005\"><figure class=\"x__sc-1an7vu1-0 kbQZSd\"><picture><img data-defer=\"view\" title=\"Image: Drama: - 40 har kollapset\" alt=\"Image: Drama: - 40 har kollapset\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81421008&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=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 bxtuZJ title dynamic-sizing\">Drama: - 40</span><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">har kollapset</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=\"Væpnet ran mot berømt juvelbutikk\" href=\"https://www.dagbladet.no/nyheter/vaepnet-ran-mot-beromt-juvelbutikk/81420847\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Væpnet ran mot berømt juvelbutikk\" alt=\"Image: Væpnet ran mot berømt juvelbutikk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81420862&amp;panoy=0&amp;panox=0&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heighty=0&amp;heightx=47.085201793722&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 dWzMnA title dynamic-sizing\">Væpnet ran</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">mot berømt</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">juvelbutikk</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=\"Ville scener\" href=\"https://www.dagbladet.no/sport/ville-scener/81420748\"><figure class=\"x__sc-1an7vu1-0 ioDOlL\"><picture><img data-defer=\"view\" title=\"Image: Ville scener\" alt=\"Image: Ville scener\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81420757&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=252&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">Ville scener</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=\"- Mye kluss\" href=\"https://www.dagbladet.no/sport/mye-kluss/81420648\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Mye kluss\" alt=\"Image: - Mye kluss\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81420650&amp;panoy=0&amp;panow=100&amp;panox=0&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dbonoY title dynamic-sizing\">- Mye kluss</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard5\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer russerne\" href=\"https://www.dagbladet.no/video/advarer-russerne/YV1HwaxQ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advarer russerne\" alt=\"Image: Advarer russerne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/YV1HwaxQ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">Advarer</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">russerne</span></h3></header></a></article><article class=\"preview columns small-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: Hudlege hyller Mys (19) metode\" href=\"https://www.dagbladet.no/tema/atopisk-eksem-hudlege-hyller-mys-19-metode/81239665\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Atopisk eksem: Hudlege hyller Mys (19) metode\" alt=\"Image: Atopisk eksem: Hudlege hyller Mys (19) metode\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81253932&amp;panoy=24.576271186441&amp;panow=49.881235154394&amp;panoh=60.169491525424&amp;panox=25.653206650831&amp;heighty=6.4327485380117&amp;heightx=33.277027027027&amp;heightw=15.202702702703&amp;heighth=86.470588235294&amp;width=320&amp;height=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 beDNpZ title dynamic-sizing\">Atopisk eksem: Hudlege</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">hyller Mys (19) metode</span></h3></header></a></article></div></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=\"Markerte homofobi-dag - droppet 17.mai\" href=\"https://www.dagbladet.no/nyheter/markerte-homofobi-dag-droppet-17mai/81420300\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Markerte homofobi-dag - droppet 17.mai\" alt=\"Image: Markerte homofobi-dag - droppet 17.mai\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81420368&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Markerte homofobi-dag</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">- droppet 17.mai</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=\"- Kriminelle infiltrerer politiet og samfunnet\" href=\"https://www.dagbladet.no/nyheter/kriminelle-infiltrerer-politiet-og-samfunnet/81413575\"><figure class=\"x__sc-1an7vu1-0 cjSQRT\"><picture><img data-defer=\"view\" title=\"Image: - Kriminelle infiltrerer politiet og samfunnet\" alt=\"Image: - Kriminelle infiltrerer politiet og samfunnet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419813&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=326&amp;compression=70\" 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\">- Kriminelle infiltrerer</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">politiet og samfunnet</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=\"Bekrefter brudd - og kjæreste\" href=\"https://www.dagbladet.no/kjendis/bekrefter-brudd-og-kjaereste/81419861\"><figure class=\"x__sc-1an7vu1-0 dvwkoI\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter brudd - og kjæreste\" alt=\"Image: Bekrefter brudd - og kjæreste\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419889&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=402&amp;height=355&amp;compression=70\" 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\">Bekrefter brudd</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- og kjæreste</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=\"Limte seg fast i rullebanen\" href=\"https://www.dagbladet.no/nyheter/limte-seg-fast-i-rullebanen/81419826\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Limte seg fast i rullebanen\" alt=\"Image: Limte seg fast i rullebanen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419828&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">Limte seg fast</span><span class=\"x__pt8tzk-0 gNDiBf title dynamic-sizing\">i rullebanen</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=\"Kåring: Norges største innebandytalenter\" href=\"https://www.dagbladet.no/sport/karing-norges-storste-innebandytalenter/81316799\"><figure class=\"x__sc-1an7vu1-0 ejHyWU\"><picture><img data-defer=\"view\" title=\"Image: Kåring: Norges største innebandytalenter\" alt=\"Image: Kåring: Norges største innebandytalenter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81316855&amp;panox=11.363636363636&amp;panoy=18.181818181818&amp;panow=79.082492424242&amp;panoh=40.214647727273&amp;heighty=0&amp;heightw=40.994420091324&amp;heighth=99.847794520548&amp;heightx=31.050228310502&amp;width=320&amp;height=204&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Kåring: Norges største</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">innebandytalenter</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=\"Fanges på film: - Ikke bra!\" href=\"https://www.dagbladet.no/video/fanges-pa-film-ikke-bra/DuToMXyk\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Fanges på film: - Ikke bra!\" alt=\"Image: Fanges på film: - Ikke bra!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/DuToMXyk-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Fanges på film:</span><span class=\"x__pt8tzk-0 glOqqI title dynamic-sizing\">- Ikke bra!</span></h3></header></a></article><div id=\"apos-medium-rectangle-perz4\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle-perz4\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle-perz4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Både snø og sommervarme\" href=\"https://www.dagbladet.no/nyheter/bade-sno-og-sommervarme/81419768\"><figure class=\"x__sc-1an7vu1-0 hlqDzP\"><picture><img data-defer=\"view\" title=\"Image: - Både snø og sommervarme\" alt=\"Image: - Både snø og sommervarme\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419815&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighty=0&amp;heightx=0&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 jdcGMN title dynamic-sizing\">- Både snø og</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">sommervarme</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=\"- Må manipulere litt\" href=\"https://www.dagbladet.no/kjendis/ma-manipulere-litt/81396705\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Må manipulere litt\" alt=\"Image: - Må manipulere litt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81396747&amp;panoy=9.8939929328622&amp;panox=0&amp;panow=100&amp;panoh=25.088339222615&amp;heightw=100&amp;heighth=100&amp;heightx=0&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\">- Må manipulere litt</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=\"Åpen om sjokket\" href=\"https://www.dagbladet.no/sport/apen-om-sjokket/81419469\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Åpen om sjokket\" alt=\"Image: Åpen om sjokket\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419473&amp;panow=100.16025673077&amp;panoh=51.318945323741&amp;panox=0&amp;panoy=0&amp;heighty=0.22831095890411&amp;heightx=27.853881278539&amp;heightw=40.791476712329&amp;heighth=100.2283109589&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Åpen om</span><span class=\"x__pt8tzk-0 cICKVW title dynamic-sizing\">sjokket</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=\"Slåssing, fyll og bortvisninger\" href=\"https://www.dagbladet.no/nyheter/slassing-fyll-og-bortvisninger/81419577\"><figure class=\"x__sc-1an7vu1-0 gpFUbf\"><picture><img data-defer=\"view\" title=\"Image: Slåssing, fyll og bortvisninger\" alt=\"Image: Slåssing, fyll og bortvisninger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419299&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=471&amp;compression=70\" 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\">Slåssing, fyll</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">og bortvisninger</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=\"Skal være flyttet til Kabul\" href=\"https://www.dagbladet.no/nyheter/skal-vaere-flyttet-til-kabul/81419588\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Skal være flyttet til Kabul\" alt=\"Image: Skal være flyttet til Kabul\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419596&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=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 hjGKKq title dynamic-sizing\">Skal være</span><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">flyttet til Kabul</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=\"- Vært veldig konsekvent\" href=\"https://www.dagbladet.no/kjendis/vaert-veldig-konsekvent/81415510\"><figure class=\"x__sc-1an7vu1-0 gFiTCV\"><picture><img data-defer=\"view\" title=\"Image: - Vært veldig konsekvent\" alt=\"Image: - Vært veldig konsekvent\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81408208&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=27.142857142857&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&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 bwzwBX title dynamic-sizing\">- Vært veldig</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">konsekvent</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- En tarvelig anklage\" href=\"https://www.dagbladet.no/kjendis/en-tarvelig-anklage/81418601\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - En tarvelig anklage\" alt=\"Image: - En tarvelig anklage\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418618&amp;panoy=28.647214854111&amp;panox=15.511551155116&amp;panow=69.856985478548&amp;panoh=19.274977718833&amp;heightx=32.751091703057&amp;heightw=40.029111790393&amp;heighth=52.16374245614&amp;heighty=24.561403508772&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 iXjdLY title dynamic-sizing\">- En tarvelig</span><span class=\"x__pt8tzk-0 cUXKOF title dynamic-sizing\">anklage</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=\"- Et helvetes sjokk\" href=\"https://www.dagbladet.no/sport/et-helvetes-sjokk/81419376\"><figure class=\"x__sc-1an7vu1-0 jyFlEO\"><picture><img data-defer=\"view\" title=\"Image: - Et helvetes sjokk\" alt=\"Image: - Et helvetes sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419442&amp;panox=0.16025673076923&amp;panow=100.16025673077&amp;panoh=27.435897692308&amp;panoy=20.769230769231&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=317&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">- Et helvetes sjokk</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Prinsessen overrasket\" href=\"https://www.dagbladet.no/video/prinsessen-overrasket/U3b0bm6N\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Prinsessen overrasket\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81417867.jpg?imageId=81417867&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/05/17/f80187f9-dcda-40e7-830f-bd558ecc680f/gif,_prinsessen.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/05/17/f80187f9-dcda-40e7-830f-bd558ecc680f/gif,_prinsessen.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cKlSIC title dynamic-sizing\">Prinsessen</span><span class=\"x__pt8tzk-0 bvXqXn title dynamic-sizing\">overrasket</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=\"Tinnitus-formelen: Frisk i rekordfart\" href=\"https://www.dagbladet.no/tema/tinnitus-formelen-frisk-i-rekordfart/81274905\"><figure class=\"x__sc-1an7vu1-0 gkSegO\"><picture><img data-defer=\"view\" title=\"Image: Tinnitus-formelen: Frisk i rekordfart\" alt=\"Image: Tinnitus-formelen: Frisk i rekordfart\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81280162&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=211&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Tinnitus-formelen:</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">Frisk i rekordfart</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=\"Høyesterettsdommer sjokkerer:- Utenkelig\" href=\"https://www.dagbladet.no/nyheter/hoyesterettsdommer-sjokkerer-utenkelig/81419486\"><figure class=\"x__sc-1an7vu1-0 jYZLUK\"><picture><img data-defer=\"view\" title=\"Image: Høyesterettsdommer sjokkerer:- Utenkelig\" alt=\"Image: Høyesterettsdommer sjokkerer:- Utenkelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419492&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=299&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Høyesterettsdommer</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">sjokkerer:- Utenkelig</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=\"- Flaut, nesten klagbart vær\" href=\"https://www.dagbladet.no/nyheter/flaut-nesten-klagbart-vaer/81419244\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Flaut, nesten klagbart vær\" alt=\"Image: - Flaut, nesten klagbart vær\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419354&amp;panow=100&amp;panoh=60.169491525424&amp;panoy=9.3220338983051&amp;panox=0&amp;heightx=23.754789272031&amp;heightw=34.48275862069&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 jGSTdz title dynamic-sizing\">- Flaut, nesten</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">klagbart vær</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=\"Mener mysteriet er løst\" href=\"https://www.dagbladet.no/nyheter/mener-mysteriet-er-lost/81418675\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Mener mysteriet er løst\" alt=\"Image: Mener mysteriet er løst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418677&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=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Mener mysteriet</span><span class=\"x__pt8tzk-0 emKkIi title dynamic-sizing\">er løst</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dukket ikke opp\" href=\"https://www.dagbladet.no/sport/dukket-ikke-opp/81419220\"><figure class=\"x__sc-1an7vu1-0 bpchQk\"><picture><img data-defer=\"view\" title=\"Image: Dukket ikke opp\" alt=\"Image: Dukket ikke opp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419224&amp;panoy=6.832298136646&amp;panox=11.618257261411&amp;panow=86.445366804979&amp;panoh=44.30641863354&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=396&amp;compression=70\" 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\">Dukket ikke opp</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard6\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"\" 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 iRrFGC\"><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=174&amp;compression=70\" 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><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=\"- Katastrofe!\" href=\"https://www.dagbladet.no/video/-katastrofe/xjbmQxt4\"><figure class=\"x__sc-1an7vu1-0 iRrFGC\"><picture><img data-defer=\"view\" title=\"Image: - Katastrofe!\" alt=\"Image: - Katastrofe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/xjbmQxt4-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 jiGVVj title dynamic-sizing\">- Katastrofe!</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=\"Fyll og bråk over hele landet\" href=\"https://www.dagbladet.no/nyheter/fyll-og-brak-over-hele-landet/81419252\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Fyll og bråk over hele landet\" alt=\"Image: Fyll og bråk over hele landet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419286&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dQSCBR title dynamic-sizing\">Fyll og bråk</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">over hele landet</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=\"- Hent barna hjem\" href=\"https://www.dagbladet.no/nyheter/hent-barna-hjem/81419085\"><figure class=\"x__sc-1an7vu1-0 hrRtCC\"><picture><img data-defer=\"view\" title=\"Image: - Hent barna hjem\" alt=\"Image: - Hent barna hjem\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419115&amp;panoy=22.430346405229&amp;panow=91.304347826087&amp;panoh=46.40522875817&amp;panox=0&amp;heighty=13.529411764706&amp;heightx=18.039215686275&amp;heightw=35.294117647059&amp;heighth=86.470588235294&amp;width=402&amp;height=419&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">- Hent barna hjem</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=\"Volden fanget på kamera\" href=\"https://www.dagbladet.no/kjendis/volden-fanget-pa-kamera/81419043\"><figure class=\"x__sc-1an7vu1-0 jDKzJI\"><picture><img data-defer=\"view\" title=\"Image: Volden fanget på kamera\" alt=\"Image: Volden fanget på kamera\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81419046&amp;panox=13.956639837398&amp;panoy=6.8571428571429&amp;panow=86.043360162602&amp;panoh=41.523809142857&amp;heightw=37.72290781893&amp;heighth=85.934489017341&amp;heighty=0&amp;heightx=35.390946502058&amp;width=402&amp;height=299&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Volden fanget</span><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">på kamera</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=\"Tatt minutter seinere: - Ikke lov\" href=\"https://www.dagbladet.no/nyheter/tatt-minutter-seinere-ikke-lov/81418963\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Tatt minutter seinere: - Ikke lov\" alt=\"Image: Tatt minutter seinere: - Ikke lov\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418969&amp;panoy=28.571428571429&amp;panox=17.241379310345&amp;panow=81.098339463602&amp;panoh=49.433106122449&amp;heighty=0&amp;heightx=48.863636363636&amp;heightw=34.722221969697&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 ddbCJZ title dynamic-sizing\">Tatt minutter</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">seinere: - Ikke lov</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=\"Pappa-studie: Alarmerende\" href=\"https://www.dagbladet.no/tema/pappa-studie-alarmerende/81303597\"><figure class=\"x__sc-1an7vu1-0 gbGggw\"><picture><img data-defer=\"view\" title=\"Image: Pappa-studie: Alarmerende\" alt=\"Image: Pappa-studie: Alarmerende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81303629&amp;panow=100.10735362319&amp;panoh=50.519584172662&amp;panoy=43.165467625899&amp;panox=0.1073536231884&amp;heighty=0.1524404109589&amp;heightx=35.160229357798&amp;heightw=40.927624770642&amp;heighth=99.467275342466&amp;width=320&amp;height=212&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Pappa-studie:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Alarmerende</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=\"- Hun må i fengsel\" href=\"https://www.dagbladet.no/video/-hun-ma-i-fengsel/uAGgxHYy\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Hun må i fengsel\" alt=\"Image: - Hun må i fengsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uAGgxHYy-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 hRdvzd title dynamic-sizing\">- Hun må</span><span class=\"x__pt8tzk-0 iVreMl title dynamic-sizing\">i fengsel</span></h3></header></a></article><div id=\"apos-medium-rectangle5\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle5\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Drama i kulissene: - Katastrofe\" href=\"https://www.dagbladet.no/sport/drama-i-kulissene-katastrofe/81418654\"><figure class=\"x__sc-1an7vu1-0 bpwXh\"><picture><img data-defer=\"view\" title=\"Image: Drama i kulissene: - Katastrofe\" alt=\"Image: Drama i kulissene: - Katastrofe\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418670&amp;panox=0.16025673076923&amp;panow=100.16025673077&amp;panoh=27.435897692308&amp;panoy=1.9230769230769&amp;heighty=0.22831095890411&amp;heightx=5.982905982906&amp;heightw=76.353276923077&amp;heighth=100.2283109589&amp;width=485&amp;height=259&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Drama i kulissene:</span><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">- Katastrofe</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=\"Liket funnet: «Hun strålte»\" href=\"https://www.dagbladet.no/nyheter/liket-funnet-hun-stralte/81418855\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Liket funnet: «Hun strålte»\" alt=\"Image: Liket funnet: «Hun strålte»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418865&amp;panow=51.879084803922&amp;panoh=16.666666513761&amp;panox=28.921568627451&amp;panoy=28.899082568807&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 jtCXvA title dynamic-sizing\">Liket funnet:</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">«Hun strålte»</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=\"- Knallhard\" href=\"https://www.dagbladet.no/kjendis/knallhard/81418825\"><figure class=\"x__sc-1an7vu1-0 enMUO\"><picture><img data-defer=\"view\" title=\"Image: - Knallhard\" alt=\"Image: - Knallhard\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418838&amp;panoy=17.021276595745&amp;panox=0&amp;panow=99.842766981132&amp;panoh=25.768321276596&amp;heighty=12.461059190031&amp;heightw=37.878787603306&amp;heighth=46.313603115265&amp;heightx=18.595041322314&amp;width=402&amp;height=368&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">- Knallhard</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Tidligere og yngre enn normalt\" href=\"https://www.dagbladet.no/nyheter/tidligere-og-yngre-enn-normalt/81418778\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Tidligere og yngre enn normalt\" alt=\"Image: - Tidligere og yngre enn normalt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418813&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=14.847161572052&amp;heightw=26.239067055394&amp;heighth=64.192139737991&amp;heightx=29.737609329446&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 criDNb title dynamic-sizing\">- Tidligere og</span><span class=\"x__pt8tzk-0 kdEriU title dynamic-sizing\">yngre enn normalt</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dommersjokk\" href=\"https://www.dagbladet.no/video/dommersjokk/SFdWo3S4\"><figure class=\"x__sc-1an7vu1-0 ksIXeg\"><picture><img data-defer=\"view\" title=\"Image: Dommersjokk\" alt=\"Image: Dommersjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/SFdWo3S4-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\">Dommersjokk</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=\"«Pappa har skrevet noe dumt»\" href=\"https://www.dagbladet.no/tema/snakker-ut-om-whisky-innleggene/81251334\"><figure class=\"x__sc-1an7vu1-0 ksIXeg\"><picture><img data-defer=\"view\" title=\"Image: «Pappa har skrevet noe dumt»\" alt=\"Image: «Pappa har skrevet noe dumt»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81251351&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=320&amp;height=175&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">«Pappa har</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">skrevet noe dumt»</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=\"Dukket opp\" href=\"https://www.dagbladet.no/kjendis/dukket-opp/81418775\"><figure class=\"x__sc-1an7vu1-0 juZrXb\"><picture><img data-defer=\"view\" title=\"Image: Dukket opp\" alt=\"Image: Dukket opp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418782&amp;panoy=20.083682008368&amp;panox=20.718232044199&amp;panow=58.471454696133&amp;panoh=30.404462761506&amp;heighty=16.019417475728&amp;heightx=45.954692556634&amp;heightw=29.665587702265&amp;heighth=72.168284466019&amp;width=485&amp;height=344&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">Dukket opp</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=\"Feirer til fjells: - Magisk\" href=\"https://www.dagbladet.no/nyheter/feirer-til-fjells-magisk/81413765\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Feirer til fjells: - Magisk\" alt=\"Image: Feirer til fjells: - Magisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81417524&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fZJFvq title dynamic-sizing\">Feirer til</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">fjells: - Magisk</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=\"Advokat: Styr unna framtidsfullmakt-fella \" href=\"https://www.dagbladet.no/tema/advokat-styr-unna-framtidsfullmakt-fella/81077382\"><figure class=\"x__sc-1an7vu1-0 dZwFXb\"><picture><img data-defer=\"view\" title=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" alt=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81242728&amp;panoy=16.551724137931&amp;panox=0.083402752293575&amp;panow=100.08340275229&amp;panoh=51.159874482759&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=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 zWscE title dynamic-sizing\">Advokat: Styr unna</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">framtidsfullmakt-fella </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=\"Utsettes for rasisme - slår tilbake\" href=\"https://www.dagbladet.no/video/utsettes-for-rasisme-slar-tilbake/31vzh4my\"><figure class=\"x__sc-1an7vu1-0 jTuAlm\"><picture><img data-defer=\"view\" title=\"Image: Utsettes for rasisme - slår tilbake\" alt=\"Image: Utsettes for rasisme - slår tilbake\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/31vzh4my-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 iNHyie title dynamic-sizing\">Utsettes for rasisme</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">- slår tilbake</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=\"Lærer (30) fikk barn med elev\" href=\"https://www.dagbladet.no/nyheter/laerer-30-fikk-barn-med-elev/81418643\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Lærer (30) fikk barn med elev\" alt=\"Image: Lærer (30) fikk barn med elev\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418658&amp;panoh=27.843137254902&amp;panoy=10.588235294118&amp;panox=0&amp;panow=100&amp;heightw=63.829787234043&amp;heighth=85.964912280702&amp;heighty=5.2631578947368&amp;heightx=18.439716312057&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Lærer (30) fikk</span><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">barn med elev</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=\"Varmeste noensinne\" href=\"https://www.dagbladet.no/nyheter/varmeste-noensinne/81418432\"><figure class=\"x__sc-1an7vu1-0 fgEAoQ\"><picture><img data-defer=\"view\" title=\"Image: Varmeste noensinne\" alt=\"Image: Varmeste noensinne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418497&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=40&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&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 dWzMnA title dynamic-sizing\">Varmeste</span><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">noensinne</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard8\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dro til legen - fant dette\" href=\"https://www.dagbladet.no/video/dro-til-legen-fant-dette/1gFyPrJZ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Dro til legen - fant dette\" alt=\"Image: Dro til legen - fant dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/1gFyPrJZ-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\">Dro til legen</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">- fant dette</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Demens-formelen: Spis og drikk dette!\" href=\"https://www.dagbladet.no/tema/demens-formelen-spis-og-drikk-dette/81180135\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Demens-formelen: Spis og drikk dette!\" alt=\"Image: Demens-formelen: Spis og drikk dette!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81202439&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Demens-formelen:</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Spis og drikk dette!</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Diagnosene som gir raskest uføretrygd\" href=\"https://www.dagbladet.no/tema/diagnosene-som-gir-raskest-uforetrygd/81368554\"><figure class=\"x__sc-1an7vu1-0 gwQmTe\"><picture><img data-defer=\"view\" title=\"Image: Diagnosene som gir raskest uføretrygd\" alt=\"Image: Diagnosene som gir raskest uføretrygd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80166524&amp;panox=0&amp;panow=99.757281553398&amp;panoh=47.931034482759&amp;panoy=23.236344827586&amp;heighty=0.34722222222222&amp;heightx=25.267401960784&amp;heightw=42.892156862745&amp;heighth=99.652777777778&amp;width=320&amp;height=209&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Diagnosene som gir</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">raskest uføretrygd</span></h3></header></a></article><article class=\"preview columns small-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=\"– Det er så respektløst!\" href=\"https://www.dagbladet.no/video/-det-er-sa-respektlost/61vlOQno\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: – Det er så respektløst!\" alt=\"Image: – Det er så respektløst!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/61vlOQno-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 ivnriz title dynamic-sizing\">– Det er så</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">respektløst!</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=\"Bilder avslører Krim-angrep\" href=\"https://www.dagbladet.no/nyheter/bilder-avslorer-krim-angrep/81418482\"><figure class=\"x__sc-1an7vu1-0 foOzbz\"><picture><img data-defer=\"view\" title=\"Image: Bilder avslører Krim-angrep\" alt=\"Image: Bilder avslører Krim-angrep\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418559&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=243&amp;compression=70\" 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\">Bilder avslører</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Krim-angrep</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=\"Verdensener lagt i håndjern\" href=\"https://www.dagbladet.no/sport/verdensener-lagt-i-handjern/81417849\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Verdensener lagt i håndjern\" alt=\"Image: Verdensener lagt i håndjern\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418453&amp;panox=8.5271317829457&amp;panow=81.395348837209&amp;panoh=32.272727272727&amp;panoy=10&amp;heightw=42.654028436019&amp;heighth=81.21546961326&amp;heighty=2.2099447513812&amp;heightx=22.748815165877&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Verdensener</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">lagt i håndjern</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Storfavoritten går på en smell\" href=\"https://www.dagbladet.no/video/storfavoritten-gar-pa-en-smell/eAk0CiL2\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Storfavoritten går på en smell\" alt=\"Image: Storfavoritten går på en smell\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/eAk0CiL2-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\">Storfavoritten</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">går på en smell</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 id=\"apos-netboard9\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard9\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Plast gruser global luftfart\" href=\"https://www.dagbladet.no/nyheter/plast-gruser-global-luftfart/81330060\"><figure class=\"x__sc-1an7vu1-0 cAHFIm\"><picture><img data-defer=\"view\" title=\"Image: Plast gruser global luftfart\" alt=\"Image: Plast gruser global luftfart\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339751&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=20&amp;panox=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&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 iXjdLY title dynamic-sizing\">Plast gruser</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">global luftfart</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=\"Åpner seg etter dødsfallet\" href=\"https://www.dagbladet.no/kjendis/apner-seg-etter-dodsfallet/81413311\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Åpner seg etter dødsfallet\" alt=\"Image: Åpner seg etter dødsfallet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81416220&amp;panoy=13.440860215054&amp;panow=69.867549668874&amp;panoh=38.709677419355&amp;panox=10.927152317881&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">Åpner seg etter</span><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">dødsfallet</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=\"Svimmel? Overlegens advarsel\" href=\"https://www.dagbladet.no/tema/svimmel-overlegens-advarsel/81240447\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Svimmel? Overlegens advarsel\" alt=\"Image: Svimmel? Overlegens advarsel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81243451&amp;panox=0.086169668246442&amp;panoy=27.129337539432&amp;panow=100.08616966825&amp;panoh=22.770289589905&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Svimmel?</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Overlegens</span><span class=\"x__pt8tzk-0 beQydf title dynamic-sizing\">advarsel</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Pinlig berørt: - Å, gud!\" href=\"https://www.dagbladet.no/video/pinlig-berort-a-gud/fONBn6J8\"><figure class=\"x__sc-1an7vu1-0 iGTxZG moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Pinlig berørt: - Å, gud!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81404856.jpg?imageId=81404856&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=237\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/05/03/90334ac2-47b9-4853-9d0c-526b2b026ab9/gif_iuel_bare_sit.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/05/03/90334ac2-47b9-4853-9d0c-526b2b026ab9/gif_iuel_bare_sit.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">Pinlig berørt:</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">- Å, gud!</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=\"Se kjendisenes 17. mai-bilder\" href=\"https://www.dagbladet.no/kjendis/se-kjendisenes-17-mai-bilder/81417664\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Se kjendisenes 17. mai-bilder\" alt=\"Image: Se kjendisenes 17. mai-bilder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81417683&amp;panow=99.842766981132&amp;panoh=34.276729245283&amp;panoy=21.698113207547&amp;panox=0.15723301886793&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">Se kjendisenes</span><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">17. mai-bilder</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=\"Prinsen dukket opp i toget\" href=\"https://www.dagbladet.no/kjendis/prinsen-dukket-opp-i-toget/81418337\"><figure class=\"x__sc-1an7vu1-0 SpJRa\"><picture><img data-defer=\"view\" title=\"Image: Prinsen dukket opp i toget\" alt=\"Image: Prinsen dukket opp i toget\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81418353&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=311&amp;compression=70\" 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\">Prinsen dukket</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">opp i toget</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Faller sju meter rett ned\" href=\"https://www.dagbladet.no/video/faller-sju-meter-rett-ned/IKqjeIHr\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Faller sju meter rett ned\" alt=\"Image: Faller sju meter rett ned\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/IKqjeIHr-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bkgkdp title dynamic-sizing\">Faller sju</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">meter rett ned</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 19: Simens ti kjappe!\" href=\"https://www.dagbladet.no/nyheter/quiz-uke-19-simens-ti-kjappe/81374284\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Quiz uke 19: Simens ti kjappe!\" alt=\"Image: Quiz uke 19: 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 19:</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-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Quiz uke 17: Simens ti kjappe!\" href=\"https://www.dagbladet.no/nyheter/quiz-uke-17-simens-ti-kjappe/81313924\"><figure class=\"x__sc-1an7vu1-0 ibyVuT\"><picture><img data-defer=\"view\" title=\"Image: Quiz uke 17: Simens ti kjappe!\" alt=\"Image: Quiz uke 17: Simens ti kjappe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81056783&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=180&amp;compression=70\" 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 17:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Simens ti kjappe!</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=\"Svarer på romanseryktene\" href=\"https://www.dagbladet.no/video/svarer-pa-romanseryktene/y5ECR8WJ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Svarer på romanseryktene\" alt=\"Image: Svarer på romanseryktene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/y5ECR8WJ-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\">Svarer på</span><span class=\"x__pt8tzk-0 ihkPAv title dynamic-sizing\">romanseryktene</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Klarer ikke stoppe: - Fader, altså!\" href=\"https://www.dagbladet.no/video/klarer-ikke-stoppe-fader-altsa/kLhO0qI7\"><figure class=\"x__sc-1an7vu1-0 iEicaO\"><picture><img data-defer=\"view\" title=\"Image: Klarer ikke stoppe: - Fader, altså!\" alt=\"Image: Klarer ikke stoppe: - Fader, altså!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kLhO0qI7-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Klarer ikke stoppe:</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">- Fader, altså!</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=\"Førerkort-formelen: Fire spørsmål avgjør\" href=\"https://www.dagbladet.no/tema/forerkort-formelen-fire-sporsmal-avgjor/81263042\"><figure class=\"x__sc-1an7vu1-0 iEicaO\"><picture><img data-defer=\"view\" title=\"Image: Førerkort-formelen: Fire spørsmål avgjør\" alt=\"Image: Førerkort-formelen: Fire spørsmål avgjør\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81270290&amp;panoy=38.386830985915&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.173708450704&amp;heightx=40.990990990991&amp;heightw=41.291290990991&amp;heighth=99.77628590604&amp;heighty=0&amp;width=320&amp;height=171&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Førerkort-formelen:</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Fire spørsmål avgjør</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Åtte humorstiler: Denne røper psykopaten\" href=\"https://www.dagbladet.no/tema/atte-humorstiler-denne-roper-psykopaten/81241514\"><figure class=\"x__sc-1an7vu1-0 jqAWdU\"><picture><img data-defer=\"view\" title=\"Image: Åtte humorstiler: Denne røper psykopaten\" alt=\"Image: Åtte humorstiler: Denne røper psykopaten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81257255&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=235&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\">Åtte humorstiler:</span><span class=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Denne røper psykopaten</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-blue\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kan slutte å fungere\" href=\"https://www.dagbladet.no/video/kan-slutte-a-fungere/wKt5PnAf\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Kan slutte å fungere\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/79595079.jpg?imageId=79595079&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/06/16/f0bc8db0-f3c2-48f7-abaa-cfa3b483a2e5/gif_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/06/16/f0bc8db0-f3c2-48f7-abaa-cfa3b483a2e5/gif_2.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">Kan slutte</span><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">å fungere</span></h3></header></a></article><div id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"ADHD-medisin:Urovekkende funn\" href=\"https://www.dagbladet.no/tema/adhd-medisinurovekkende-funn/81349829\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: ADHD-medisin:Urovekkende funn\" alt=\"Image: ADHD-medisin:Urovekkende funn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81350241&amp;panow=66.025641025641&amp;panoh=35.897435897436&amp;panoy=44.845360824742&amp;panox=0&amp;heighty=0&amp;heightx=12.227074235808&amp;heightw=38.427947598253&amp;heighth=100&amp;width=320&amp;height=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 diUuRk title dynamic-sizing\">ADHD-medisin:Urovekkende funn</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=\"Skriker av frykt\" href=\"https://www.dagbladet.no/video/skriker-av-frykt/QqnSmszk\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Skriker av frykt\" alt=\"Image: Skriker av frykt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/QqnSmszk-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 eJvLkS title dynamic-sizing\">Skriker</span><span class=\"x__pt8tzk-0 kuSqyf title dynamic-sizing\">av frykt</span></h3></header></a></article></div></div><div id=\"apos-netboard12\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard12&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nye funn: Vanene avslører kvinnelige psykopater\" href=\"https://www.dagbladet.no/tema/nye-funn-vanene-avslorer-kvinnelige-psykopater/81236075\"><figure class=\"x__sc-1an7vu1-0 hjCnKb\"><picture><img data-defer=\"view\" title=\"Image: Nye funn: Vanene avslører kvinnelige psykopater\" alt=\"Image: Nye funn: Vanene avslører kvinnelige psykopater\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81236114&amp;panoy=26.241134751773&amp;panow=100.08616966825&amp;panoh=51.192778723404&amp;panox=0.086169668246442&amp;heightx=30.803571428571&amp;heightw=40.70616875&amp;heighth=100.12202550336&amp;heighty=0.1220255033557&amp;width=320&amp;height=192&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jRIgeY title dynamic-sizing\">Nye funn: Vanene avslører</span><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">kvinnelige psykopater</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=\"Stoltenberg raser: - Alvorlige konsekvenser\" href=\"https://www.dagbladet.no/video/stoltenberg-raser-alvorlige-konsekvenser/kjoVsMWu\"><figure class=\"x__sc-1an7vu1-0 jJDuNs\"><picture><img data-defer=\"view\" title=\"Image: Stoltenberg raser: - Alvorlige konsekvenser\" alt=\"Image: Stoltenberg raser: - Alvorlige konsekvenser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kjoVsMWu-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\">Stoltenberg raser:</span><span class=\"x__pt8tzk-0 hpQSgl title dynamic-sizing\">- Alvorlige konsekvenser</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>"]