["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .inQdkY.inQdkY.inQdkY.inQdkY{height:0;padding-bottom:65.77%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .jjcUMQ.jjcUMQ.jjcUMQ.jjcUMQ{height:0;padding-bottom:58.35%;}/*!sc*/ .hWNzRJ.hWNzRJ.hWNzRJ.hWNzRJ{height:0;padding-bottom:73.75%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .dRaWNy.dRaWNy.dRaWNy.dRaWNy{height:0;padding-bottom:75.87%;}/*!sc*/ .jrlTlV.jrlTlV.jrlTlV.jrlTlV{height:0;padding-bottom:102.98%;}/*!sc*/ .hpZPQm.hpZPQm.hpZPQm.hpZPQm{height:0;padding-bottom:68.65%;}/*!sc*/ .ctaOyT.ctaOyT.ctaOyT.ctaOyT{height:0;padding-bottom:73.88%;}/*!sc*/ .hWqjha.hWqjha.hWqjha.hWqjha{height:0;padding-bottom:77.5%;}/*!sc*/ .imSToD.imSToD.imSToD.imSToD{height:0;padding-bottom:78.12%;}/*!sc*/ .buKvZu.buKvZu.buKvZu.buKvZu{height:0;padding-bottom:81.44%;}/*!sc*/ .bkGnWt.bkGnWt.bkGnWt.bkGnWt{height:0;padding-bottom:59.17%;}/*!sc*/ .ebIGPt.ebIGPt.ebIGPt.ebIGPt{height:0;padding-bottom:52.81%;}/*!sc*/ .ldHUSz.ldHUSz.ldHUSz.ldHUSz{height:0;padding-bottom:66.66%;}/*!sc*/ .hWTYSx.hWTYSx.hWTYSx.hWTYSx{height:0;padding-bottom:81.34%;}/*!sc*/ .ZqfXQ.ZqfXQ.ZqfXQ.ZqfXQ{height:0;padding-bottom:73.12%;}/*!sc*/ .gYoHKl.gYoHKl.gYoHKl.gYoHKl{height:0;padding-bottom:55.31%;}/*!sc*/ .ctRdbX.ctRdbX.ctRdbX.ctRdbX{height:0;padding-bottom:133.58%;}/*!sc*/ .gSabaN.gSabaN.gSabaN.gSabaN{height:0;padding-bottom:111.69%;}/*!sc*/ .gtMzqw.gtMzqw.gtMzqw.gtMzqw{height:0;padding-bottom:109.7%;}/*!sc*/ .kByDQu.kByDQu.kByDQu.kByDQu{height:0;padding-bottom:53.12%;}/*!sc*/ .gkOGzu.gkOGzu.gkOGzu.gkOGzu{height:0;padding-bottom:59.58%;}/*!sc*/ .ldkMOS.ldkMOS.ldkMOS.ldkMOS{height:0;padding-bottom:51.54%;}/*!sc*/ .btjLaZ.btjLaZ.btjLaZ.btjLaZ{height:0;padding-bottom:97.26%;}/*!sc*/ .gikwvT.gikwvT.gikwvT.gikwvT{height:0;padding-bottom:121.39%;}/*!sc*/ .GzIqd.GzIqd.GzIqd.GzIqd{height:0;padding-bottom:58.43%;}/*!sc*/ .gzJWxx.gzJWxx.gzJWxx.gzJWxx{height:0;padding-bottom:84.53%;}/*!sc*/ .jAXojA.jAXojA.jAXojA.jAXojA{height:0;padding-bottom:66.16%;}/*!sc*/ .krHhho.krHhho.krHhho.krHhho{height:0;padding-bottom:54.02%;}/*!sc*/ .bqoCfD.bqoCfD.bqoCfD.bqoCfD{height:0;padding-bottom:59.37%;}/*!sc*/ .fdycFS.fdycFS.fdycFS.fdycFS{height:0;padding-bottom:62.5%;}/*!sc*/ .dDJbiB.dDJbiB.dDJbiB.dDJbiB{height:0;padding-bottom:67.21%;}/*!sc*/ .jOMhbl.jOMhbl.jOMhbl.jOMhbl{height:0;padding-bottom:76.25%;}/*!sc*/ .JFmgR.JFmgR.JFmgR.JFmgR{height:0;padding-bottom:109.2%;}/*!sc*/ .lmdjnV.lmdjnV.lmdjnV.lmdjnV{height:0;padding-bottom:55.93%;}/*!sc*/ .gjAolr.gjAolr.gjAolr.gjAolr{height:0;padding-bottom:53.75%;}/*!sc*/ data-styled.g184[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,inQdkY,fnQDHb,jjcUMQ,hWNzRJ,kviAry,dRaWNy,jrlTlV,hpZPQm,ctaOyT,hWqjha,imSToD,buKvZu,bkGnWt,ebIGPt,ldHUSz,hWTYSx,ZqfXQ,gYoHKl,ctRdbX,gSabaN,gtMzqw,kByDQu,gkOGzu,ldkMOS,btjLaZ,gikwvT,GzIqd,gzJWxx,jAXojA,krHhho,bqoCfD,fdycFS,dDJbiB,jOMhbl,JFmgR,lmdjnV,gjAolr,\"}/*!sc*/ .kauVAS.kauVAS.kauVAS.kauVAS{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kauVAS.kauVAS.kauVAS.kauVAS{font-size:2.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .ZTWfd.ZTWfd.ZTWfd.ZTWfd{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.ZTWfd.ZTWfd.ZTWfd.ZTWfd{font-size:2.5em!important;}}/*!sc*/ .lplqa-d.lplqa-d.lplqa-d.lplqa-d{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.lplqa-d.lplqa-d.lplqa-d.lplqa-d{font-size:1.2em!important;}}/*!sc*/ .kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:8.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:2.9em!important;}}/*!sc*/ .bWzzkU.bWzzkU.bWzzkU.bWzzkU{font-size:7.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bWzzkU.bWzzkU.bWzzkU.bWzzkU{font-size:2.6em!important;}}/*!sc*/ .wpfcp.wpfcp.wpfcp.wpfcp{font-size:7.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.wpfcp.wpfcp.wpfcp.wpfcp{font-size:2.7em!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*/ .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*/ .dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:1.9em!important;}}/*!sc*/ .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*/ .cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:1.5em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .hXcwPX.hXcwPX.hXcwPX.hXcwPX{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.hXcwPX.hXcwPX.hXcwPX.hXcwPX{font-size:2.6em!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*/ .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*/ .iAWFly.iAWFly.iAWFly.iAWFly{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iAWFly.iAWFly.iAWFly.iAWFly{font-size:2.2em!important;}}/*!sc*/ .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*/ .bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:1.5em!important;}}/*!sc*/ .kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:0.7em!important;}}/*!sc*/ .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*/ .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*/ .inksEV.inksEV.inksEV.inksEV{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.inksEV.inksEV.inksEV.inksEV{font-size:1.3em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .bQofrl.bQofrl.bQofrl.bQofrl{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bQofrl.bQofrl.bQofrl.bQofrl{font-size:0.7em!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*/ .cZmotM.cZmotM.cZmotM.cZmotM{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cZmotM.cZmotM.cZmotM.cZmotM{font-size:0.9em!important;}}/*!sc*/ .eVBoHG.eVBoHG.eVBoHG.eVBoHG{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.eVBoHG.eVBoHG.eVBoHG.eVBoHG{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*/ .ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.ePuSwO.ePuSwO.ePuSwO.ePuSwO{font-size:2.9em!important;}}/*!sc*/ .jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:1.8em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .itkiNJ.itkiNJ.itkiNJ.itkiNJ{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.itkiNJ.itkiNJ.itkiNJ.itkiNJ{font-size:0.9em!important;}}/*!sc*/ .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*/ .kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:1.3em!important;}}/*!sc*/ .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*/ .iKalhP.iKalhP.iKalhP.iKalhP{font-size:7.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iKalhP.iKalhP.iKalhP.iKalhP{font-size:2.7em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .eElPMU.eElPMU.eElPMU.eElPMU{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.eElPMU.eElPMU.eElPMU.eElPMU{font-size:3em!important;}}/*!sc*/ .ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:2.8em!important;}}/*!sc*/ .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*/ .eCHIew.eCHIew.eCHIew.eCHIew{font-size:9.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.eCHIew.eCHIew.eCHIew.eCHIew{font-size:3.5em!important;}}/*!sc*/ .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*/ .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*/ .iEukpb.iEukpb.iEukpb.iEukpb{font-size:8.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iEukpb.iEukpb.iEukpb.iEukpb{font-size:3.1em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:1.8em!important;}}/*!sc*/ .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*/ .ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:6.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:2.4em!important;}}/*!sc*/ .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*/ .kukeCs.kukeCs.kukeCs.kukeCs{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kukeCs.kukeCs.kukeCs.kukeCs{font-size:2.2em!important;}}/*!sc*/ .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*/ .flLVjk.flLVjk.flLVjk.flLVjk{font-size:11.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.flLVjk.flLVjk.flLVjk.flLVjk{font-size:4em!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*/ .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*/ .ijicdz.ijicdz.ijicdz.ijicdz{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ijicdz.ijicdz.ijicdz.ijicdz{font-size:1em!important;}}/*!sc*/ .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*/ .gFDBEe.gFDBEe.gFDBEe.gFDBEe{font-size:8.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gFDBEe.gFDBEe.gFDBEe.gFDBEe{font-size:3.1em!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*/ .jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jIyTDK.jIyTDK.jIyTDK.jIyTDK{font-size:1.3em!important;}}/*!sc*/ .dHKjeh.dHKjeh.dHKjeh.dHKjeh{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dHKjeh.dHKjeh.dHKjeh.dHKjeh{font-size:1.3em!important;}}/*!sc*/ .egjpuh.egjpuh.egjpuh.egjpuh{font-size:8.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.egjpuh.egjpuh.egjpuh.egjpuh{font-size:2.9em!important;}}/*!sc*/ .bpsQVB.bpsQVB.bpsQVB.bpsQVB{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bpsQVB.bpsQVB.bpsQVB.bpsQVB{font-size:2.1em!important;}}/*!sc*/ .dqFtBy.dqFtBy.dqFtBy.dqFtBy{font-size:11em!important;}/*!sc*/ @media only screen and (max-width:640px){.dqFtBy.dqFtBy.dqFtBy.dqFtBy{font-size:3.9em!important;}}/*!sc*/ .hXgjw.hXgjw.hXgjw.hXgjw{font-size:9.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.hXgjw.hXgjw.hXgjw.hXgjw{font-size:3.3em!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*/ .jCkLvS.jCkLvS.jCkLvS.jCkLvS{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jCkLvS.jCkLvS.jCkLvS.jCkLvS{font-size:2.6em!important;}}/*!sc*/ .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*/ .jwrbOd.jwrbOd.jwrbOd.jwrbOd{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.jwrbOd.jwrbOd.jwrbOd.jwrbOd{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*/ .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*/ .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*/ .jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:1.8em!important;}}/*!sc*/ data-styled.g185[id=\"x__pt8tzk-0\"]{content:\"kauVAS,hrVcDN,gPIxea,jiGVVj,ZTWfd,lplqa-d,kUqUJf,bWzzkU,wpfcp,hbwikt,fFAiTK,dfgvpn,gRLJwN,cJcNIn,jfvMWJ,cFtCN,dJenrE,dA-Dohz,hXcwPX,fNDhDy,jEhvtw,iAWFly,bvXqXn,bNRoJL,kwLuaB,jGSTdz,dWzMnA,inksEV,gVRWAB,epoJzD,kNhGgX,bQofrl,jfhrCI,cZmotM,eVBoHG,frzFun,ePuSwO,jtCXvA,dLwqhJ,lfBuL,LzBnW,cyVXzf,itkiNJ,ddbCJZ,kMqJSM,iXjdLY,iKalhP,eYoKgk,bwGQrt,iYgBvA,iNHyie,eElPMU,ggbHpa,ctWqNs,eCHIew,hPDIHE,dyaAfc,iEukpb,kVJNPR,dfserP,iFlEmK,bxtuZJ,gWsWwS,hsPeia,ldTjgH,bWSnVS,kukeCs,gLHLEv,flLVjk,hjGKKq,jdcGMN,ijicdz,bwzwBX,gFDBEe,Uccen,jIyTDK,dHKjeh,egjpuh,bpsQVB,dqFtBy,hXgjw,iVreMl,jCkLvS,tqGkg,jwrbOd,dPoeFo,zWscE,gjHDge,fIeyCx,jFsmoq,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslørt som utro\" href=\"https://www.dagbladet.no/tema/avslort-som-utro/75990447\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Avslørt som utro\" alt=\"Image: Avslørt som utro\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75990603&amp;panow=100.16260487805&amp;panoy=0&amp;panox=0.16260487804878&amp;panoh=59.770120689655&amp;heightx=16.078431372549&amp;heightw=34.248368627451&amp;heighth=100.2331048951&amp;heighty=0.23310489510489&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">Avslørt</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">som utro</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-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russerne må løpe for livet\" href=\"https://www.dagbladet.no/video/her-angripes-russerne-i-nattemorket/GgSlXiGt\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Russerne må løpe for livet\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76116049.jpg?imageId=76116049&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/16/a8ce8b94-f745-470a-94df-3668b404765a/dronegif2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/16/a8ce8b94-f745-470a-94df-3668b404765a/dronegif2.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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Russerne må</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">løpe for livet</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bekrefter Eurovision-svindel\" href=\"https://www.dagbladet.no/kjendis/bekrefter-eurovision-svindel/76138931\"><figure class=\"x__sc-1an7vu1-0 inQdkY\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter Eurovision-svindel\" alt=\"Image: Bekrefter Eurovision-svindel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76138953&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=0&amp;panox=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=485&amp;height=319\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ZTWfd title dynamic-sizing\">Bekrefter</span><span class=\"x__pt8tzk-0 lplqa-d title dynamic-sizing\">Eurovision-svindel</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nådeløs etter 6-0\" href=\"https://www.dagbladet.no/sport/nadelos-etter-6-0/76139136\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Nådeløs etter 6-0\" alt=\"Image: Nådeløs etter 6-0\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76139143&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\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">Nådeløs</span><span class=\"x__pt8tzk-0 bWzzkU title dynamic-sizing\">etter 6-0</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Løy om millionsum\" href=\"https://www.dagbladet.no/kjendis/loy-om-millionsum/76126724\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Løy om millionsum\" alt=\"Image: - Løy om millionsum\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76127528&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 wpfcp title dynamic-sizing\">- Løy om</span><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">millionsum</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ny russisk oberst drept\" href=\"https://www.dagbladet.no/nyheter/ny-russisk-oberst-drept/76138229\"><figure class=\"x__sc-1an7vu1-0 jjcUMQ\"><picture><img data-defer=\"view\" title=\"Image: - Ny russisk oberst drept\" alt=\"Image: - Ny russisk oberst drept\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76138619&amp;panoy=46.082949308756&amp;panow=72.413793103448&amp;panoh=32.718894009217&amp;panox=0&amp;heighty=31.944444444444&amp;heightx=11.458333333333&amp;heightw=31.25&amp;heighth=68.055555555556&amp;width=485&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">- Ny russisk</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">oberst drept</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ser ikke lastebilen\" href=\"https://www.dagbladet.no/video/ser-ikke-lastebilen/IovFIdtz\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Ser ikke lastebilen\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76116211.jpg?imageId=76116211&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/16/ee411999-262d-4156-b761-0646a778c3e3/syklist_faller_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/16/ee411999-262d-4156-b761-0646a778c3e3/syklist_faller_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">Ser ikke</span><span class=\"x__pt8tzk-0 cJcNIn title dynamic-sizing\">lastebilen</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kuttet alkohol - fikk ny avhengighet\" href=\"https://www.dagbladet.no/tema/jan-erik-53-kuttet-alkohol-fikk-ny-avhengighet/76093825\"><figure class=\"x__sc-1an7vu1-0 hWNzRJ\"><picture><img data-defer=\"view\" title=\"Image: Kuttet alkohol - fikk ny avhengighet\" alt=\"Image: Kuttet alkohol - fikk ny avhengighet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76093859&amp;panow=100&amp;panoh=51.094890510949&amp;panoy=4.8330729927007&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=236\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Kuttet alkohol -</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">fikk ny avhengighet</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle2\" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle2&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=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nå kommer spøkelset\" href=\"https://www.dagbladet.no/meninger/nato-som-spokelse/76137181\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Nå kommer spøkelset\" alt=\"Image: Nå kommer spøkelset\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76137741&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=20.714285714286&amp;heighty=0&amp;heightx=38.914027149321&amp;heightw=40.723981900452&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dJenrE title dynamic-sizing\">Nå kommer</span><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">spøkelset</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kritiseres: - Farlig\" href=\"https://www.dagbladet.no/kjendis/kritiseres-farlig/76138332\"><figure class=\"x__sc-1an7vu1-0 dRaWNy\"><picture><img data-defer=\"view\" title=\"Image: Kritiseres: - Farlig\" alt=\"Image: Kritiseres: - Farlig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76138370&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=305\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">Kritiseres:</span><span class=\"x__pt8tzk-0 hXcwPX title dynamic-sizing\">- Farlig</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ventet fire måneder - måtte amputere\" href=\"https://www.dagbladet.no/nyheter/ventet-fire-maneder-matte-amputere/76127197\"><figure class=\"x__sc-1an7vu1-0 jrlTlV\"><picture><img data-defer=\"view\" title=\"Image: Ventet fire måneder - måtte amputere\" alt=\"Image: Ventet fire måneder - måtte amputere\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76130399&amp;panox=0&amp;panow=100&amp;panoh=63.963963963964&amp;panoy=36.036036036036&amp;heighty=0&amp;heightx=67.741935483871&amp;heightw=32.258064516129&amp;heighth=100&amp;width=402&amp;height=414\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Ventet fire måneder</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">- måtte amputere</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vakte uro på Stortinget\" href=\"https://www.dagbladet.no/nyheter/vakte-uro-pa-stortinget/76112054\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Vakte uro på Stortinget\" alt=\"Image: Vakte uro på Stortinget\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76129935&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">Vakte uro på</span><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">Stortinget</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Får verden til å måpe\" href=\"https://www.dagbladet.no/video/sett-av-50-millioner/Lsg8Qihq\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Får verden til å måpe\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76120049.jpg?imageId=76120049&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/13/83124fd8-efcb-43f8-a748-8d76740aa839/gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/13/83124fd8-efcb-43f8-a748-8d76740aa839/gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bvXqXn title dynamic-sizing\">Får verden</span><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">til å måpe</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=\"Metoden hylles: Angstfri på fire dager\" href=\"https://www.dagbladet.no/tema/metoden-hylles-angstfri-pa-fire-dager/75949271\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Metoden hylles: Angstfri på fire dager\" alt=\"Image: Metoden hylles: Angstfri på fire dager\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76050232&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=49.320023611111&amp;panoy=13.888888888889&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Metoden hylles:</span><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Angstfri på fire dager</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Helomvending\" href=\"https://www.dagbladet.no/sport/helomvending/76135631\"><figure class=\"x__sc-1an7vu1-0 hpZPQm\"><picture><img data-defer=\"view\" title=\"Image: Helomvending\" alt=\"Image: Helomvending\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76135669&amp;panoy=7.8571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=485&amp;height=333\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">Helomvending</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sparkingen er ubegripelig\" href=\"https://www.dagbladet.no/meninger/youre-fired/76095055\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Sparkingen er ubegripelig\" alt=\"Image: Sparkingen er ubegripelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76128325&amp;panoy=21.752265861027&amp;panox=32&amp;panow=42.2&amp;panoh=21.752265861027&amp;heightw=14.040561622465&amp;heighth=34.507042253521&amp;heighty=14.319248826291&amp;heightx=42.433697347894&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">Sparkingen er</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">ubegripelig</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Forskere: Sexparasitt gjør deg mer sexy\" href=\"https://www.dagbladet.no/nyheter/forskere-sexparasitt-gjor-deg-mer-sexy/76134459\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Forskere: Sexparasitt gjør deg mer sexy\" alt=\"Image: Forskere: Sexparasitt gjør deg mer sexy\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76134516&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\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">Forskere: Sexparasitt</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">gjør deg mer sexy</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gutt (13) omkom i skrekkulykke\" href=\"https://www.dagbladet.no/nyheter/gutt-13-omkom-i-skrekkulykke/76126199\"><figure class=\"x__sc-1an7vu1-0 ctaOyT\"><picture><img data-defer=\"view\" title=\"Image: Gutt (13) omkom i skrekkulykke\" alt=\"Image: Gutt (13) omkom i skrekkulykke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76126644&amp;panox=0&amp;panow=100&amp;panoh=85.757575757576&amp;panoy=0&amp;heightw=100&amp;heighth=85.757575757576&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=297\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Gutt (13) omkom</span><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">i skrekkulykke</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-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Produksjonen bryter inn: - Stopp!\" href=\"https://www.dagbladet.no/video/produksjonen-bryter-inn-stopp/FBcJCtNd\"><figure class=\"x__sc-1an7vu1-0 hWqjha moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Produksjonen bryter inn: - Stopp!\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/75497721.jpg?imageId=75497721&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=248\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/02/28/3666d601-5053-4aad-8976-ed87586a77ab/90_days_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/02/28/3666d601-5053-4aad-8976-ed87586a77ab/90_days_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bQofrl title dynamic-sizing\">Produksjonen bryter</span><span class=\"x__pt8tzk-0 jfhrCI title dynamic-sizing\">inn: - Stopp!</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=\"Hudlege: Dette stopper hårtap\" href=\"https://www.dagbladet.no/tema/hudlege-behandlingen-som-stopper-hartap/76000168\"><figure class=\"x__sc-1an7vu1-0 imSToD\"><picture><img data-defer=\"view\" title=\"Image: Hudlege: Dette stopper hårtap\" alt=\"Image: Hudlege: Dette stopper hårtap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76000253&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=250\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">Hudlege: Dette</span><span class=\"x__pt8tzk-0 eVBoHG title dynamic-sizing\">stopper hårtap</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tina (46) testet kollagenpulver: - Stolt av huden \" href=\"https://www.dagbladet.no/annonse/stolt-av-gloden-og-spensten-i-huden-min/75710490\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2019/01/07/osl_logo_black_45.png\" data-defer=\"view\" alt=\"Oslo Skin Lab logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Tina (46) testet kollagenpulver: - Stolt av huden \" alt=\"Image: Tina (46) testet kollagenpulver: - Stolt av huden \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/75710523.jpg?imageId=75710523&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=100.000000&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Tina (46) testet</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">kollagenpulver:</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">- Stolt av huden </span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span>Oslo Skin Lab</span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Den nye supergruppa\" href=\"https://www.dagbladet.no/kultur/den-nye-supergruppa/76128262\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Den nye supergruppa\" alt=\"Image: Den nye supergruppa\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76128306&amp;panoh=83.529411764706&amp;panoy=14.117647058824&amp;panox=2.7149321266968&amp;panow=94.570135746606&amp;heightx=9.9009900990099&amp;heightw=89.108910891089&amp;heighth=97.350993377483&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"dice-wrap\"><svg class=\"dice\" width=\"100%\" height=\"100%\" viewBox=\"0 0 100 100\" preserveAspectRatio=\"none\"><rect class=\"face\" x=\"0\" y=\"0\" width=\"100\" height=\"100\"></rect><path class=\"face-shade\" d=\"M 0 0 L 100 0 L 0 100 z\"></path><circle class=\"pip\" cx=\"25\" cy=\"25\" r=\"10\"></circle><circle class=\"pip\" cx=\"25\" cy=\"75\" r=\"10\"></circle><circle class=\"pip\" cx=\"50\" cy=\"50\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"25\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"75\" r=\"10\"></circle></svg></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ePuSwO title dynamic-sizing\">Den nye</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">supergruppa</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Raser: - Umoden\" href=\"https://www.dagbladet.no/nyheter/raser-umoden/76135003\"><figure class=\"x__sc-1an7vu1-0 buKvZu\"><picture><img data-defer=\"view\" title=\"Image: Raser: - Umoden\" alt=\"Image: Raser: - Umoden\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76135014&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=485&amp;height=395\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">Raser: - Umoden</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Har blitt gale\" href=\"https://www.dagbladet.no/sport/har-blitt-gale/76137773\"><figure class=\"x__sc-1an7vu1-0 bkGnWt\"><picture><img data-defer=\"view\" title=\"Image: - Har blitt gale\" alt=\"Image: - Har blitt gale\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76137786&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=287\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">- Har blitt gale</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"80-åring skulle på date - mistet lappen\" href=\"https://www.dagbladet.no/nyheter/80-aring-skulle-pa-date-mistet-lappen/76135791\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: 80-åring skulle på date - mistet lappen\" alt=\"Image: 80-åring skulle på date - mistet lappen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76135824&amp;panoy=25.531914893617&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;heightx=0&amp;heightw=100&amp;heighth=85.498489425982&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 lfBuL title dynamic-sizing\">80-åring skulle på</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">date - mistet lappen</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Emilie om ensomheten i Oslo\" href=\"https://www.dagbladet.no/kjendis/trosser-kritikken-ville-gjort-det-igjen/75951863\"><figure class=\"x__sc-1an7vu1-0 ebIGPt\"><picture><img data-defer=\"view\" title=\"Image: Emilie om ensomheten i Oslo\" alt=\"Image: Emilie om ensomheten i Oslo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75952454&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=169\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Emilie om</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">ensomheten i Oslo</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skulle bare bade\" href=\"https://www.dagbladet.no/video/badeflausen-gar-viralt/xRHtFGqd\"><figure class=\"x__sc-1an7vu1-0 ebIGPt moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Skulle bare bade\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/75121254.jpg?imageId=75121254&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=169\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/01/12/bcc15a3f-c198-47f7-9f99-a2c30cd2662a/brygge_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/01/12/bcc15a3f-c198-47f7-9f99-a2c30cd2662a/brygge_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 itkiNJ title dynamic-sizing\">Skulle bare bade</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Må oppleves!\" href=\"https://www.dagbladet.no/kultur/ma-oppleves/76135137\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Må oppleves!\" alt=\"Image: Må oppleves!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76135251&amp;panow=100.00373779904&amp;panoy=16.546762589928&amp;panox=0.0037377990430628&amp;panoh=51.084756834532&amp;heighth=100.00531428571&amp;heighty=0.0053142857142866&amp;heightx=44.796380090498&amp;heightw=40.727516742081&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"dice-wrap\"><svg class=\"dice\" width=\"100%\" height=\"100%\" viewBox=\"0 0 100 100\" preserveAspectRatio=\"none\"><rect class=\"face\" x=\"0\" y=\"0\" width=\"100\" height=\"100\"></rect><path class=\"face-shade\" d=\"M 0 0 L 100 0 L 0 100 z\"></path><circle class=\"pip\" cx=\"25\" cy=\"25\" r=\"10\"></circle><circle class=\"pip\" cx=\"25\" cy=\"50\" r=\"10\"></circle><circle class=\"pip\" cx=\"25\" cy=\"75\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"25\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"50\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"75\" r=\"10\"></circle></svg></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">Må oppleves!</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Uskyldig fengslet for drap i 18 år\" href=\"https://www.dagbladet.no/nyheter/uskyldig-fengslet-for-drap-i-18-ar/76113076\"><figure class=\"x__sc-1an7vu1-0 ldHUSz\"><picture><img data-defer=\"view\" title=\"Image: Uskyldig fengslet for drap i 18 år\" alt=\"Image: Uskyldig fengslet for drap i 18 år\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76114495&amp;panoy=31.578947368421&amp;panox=23.558897243108&amp;panow=52.380952380952&amp;panoh=26.691729323308&amp;heightx=35.294117647059&amp;heightw=27.863777089783&amp;heighth=68.055555555556&amp;heighty=24.537037037037&amp;width=402&amp;height=268\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Uskyldig fengslet</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">for drap i 18 år</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Klagestorm: - Fuck dere!\" href=\"https://www.dagbladet.no/nyheter/klagestorm-fuck-dere/76134664\"><figure class=\"x__sc-1an7vu1-0 hWTYSx\"><picture><img data-defer=\"view\" title=\"Image: Klagestorm: - Fuck dere!\" alt=\"Image: Klagestorm: - Fuck dere!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76134788&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=327\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">Klagestorm:</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">- Fuck dere!</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sier nei til Sverige og Finland\" href=\"https://www.dagbladet.no/nyheter/sier-nei-til-sverige-og-finland/76131120\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Sier nei til Sverige og Finland\" alt=\"Image: Sier nei til Sverige og Finland\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76131123&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">Sier nei til</span><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">Sverige og Finland</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tabben går viralt\" href=\"https://www.dagbladet.no/video/tar-bratt-slutt/QFlpE31Q\"><figure class=\"x__sc-1an7vu1-0 ZqfXQ moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Tabben går viralt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76107679.jpg?imageId=76107679&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=234\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2021/11/09/851651bf-f122-4d71-a92f-f9ffcdd2e436/rumpe_gif_3.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2021/11/09/851651bf-f122-4d71-a92f-f9ffcdd2e436/rumpe_gif_3.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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Tabben går viralt</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=\"Nakstad fant kjærligheten\" href=\"https://www.dagbladet.no/tema/nakstad-fant-kjaerligheten/75719156\"><figure class=\"x__sc-1an7vu1-0 gYoHKl\"><picture><img data-defer=\"view\" title=\"Image: Nakstad fant kjærligheten\" alt=\"Image: Nakstad fant kjærligheten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75739459&amp;panoy=16.546762589928&amp;panow=100&amp;panoh=51.079136690647&amp;panox=0&amp;heighty=0&amp;heightx=26.818181818182&amp;heightw=40.909090909091&amp;heighth=100&amp;width=320&amp;height=177\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Nakstad fant</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">kjærligheten</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slutte? Prøv disse røykestopp-tipsene! \" href=\"https://www.dagbladet.no/annonsorinnhold/v/dagbladet/nicorette/roykeslutt-en-uke-tar-du-utfordringen/11130141/\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/10/26/Nicorette-Norway-Logo_dark1.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Slutte? Prøv disse røykestopp-tipsene! \" alt=\"Image: Slutte? Prøv disse røykestopp-tipsene! \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/76093072.jpg?imageId=76093072&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=91.115702&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Slutte? Prøv disse</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">røykestopp-tipsene! </span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sjokkerer med nye metoder\" href=\"https://www.dagbladet.no/sport/redd-for-det-vanlige-livet/76062329\"><figure class=\"x__sc-1an7vu1-0 ctRdbX\"><picture><img data-defer=\"view\" title=\"Image: Sjokkerer med nye metoder\" alt=\"Image: Sjokkerer med nye metoder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76025001&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heightx=15.837104072398&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=537\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Sjokkerer med</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">nye metoder</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dyrere og dårligere løsninger\" href=\"https://www.dagbladet.no/meninger/dyrere-og-darligere-losninger/76094528\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dyrere og dårligere løsninger\" alt=\"Image: Dyrere og dårligere løsninger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76128889&amp;panoy=7.8571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;heightx=38.461538461538&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">Dyrere og</span><span class=\"x__pt8tzk-0 eElPMU title dynamic-sizing\">dårligere</span><span class=\"x__pt8tzk-0 ggbHpa title dynamic-sizing\">løsninger</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Putin-venn advares\" href=\"https://www.dagbladet.no/sport/putin-venn-advares/76127474\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Putin-venn advares\" alt=\"Image: Putin-venn advares\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76128058&amp;panoy=26.388888888889&amp;panox=0&amp;panow=100&amp;panoh=49.305555555556&amp;heightx=22.429906542056&amp;heightw=42.056074766355&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">Putin-venn</span><span class=\"x__pt8tzk-0 eCHIew title dynamic-sizing\">advares</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Mest ekstreme jeg har vært borti\" href=\"https://www.dagbladet.no/nyheter/mest-ekstreme-jeg-har-vaert-borti/76126802\"><figure class=\"x__sc-1an7vu1-0 gSabaN\"><picture><img data-defer=\"view\" title=\"Image: - Mest ekstreme jeg har vært borti\" alt=\"Image: - Mest ekstreme jeg har vært borti\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76135603&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=449\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">- Mest ekstreme</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">jeg har vært borti</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-12 medium-12 large-12 \" 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-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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Legestudent fikk sjokkbeskjed i klasserommet\" href=\"https://www.dagbladet.no/nyheter/legestudent-fikk-sjokkbeskjed-i-klasserommet/76120800\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Legestudent fikk sjokkbeskjed i klasserommet\" alt=\"Image: Legestudent fikk sjokkbeskjed i klasserommet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76120866&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\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">Legestudent fikk</span><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">sjokkbeskjed</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">i klasserommet</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Jeg mistet hodet\" href=\"https://www.dagbladet.no/kjendis/jeg-mistet-hodet/76106241\"><figure class=\"x__sc-1an7vu1-0 buKvZu\"><picture><img data-defer=\"view\" title=\"Image: - Jeg mistet hodet\" alt=\"Image: - Jeg mistet hodet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76106312&amp;panoy=27.301587301587&amp;panox=0&amp;panow=100&amp;panoh=22.539682539683&amp;heightx=0&amp;heighty=0&amp;heightw=91.836734693878&amp;heighth=100&amp;width=485&amp;height=395\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">- Jeg mistet hodet</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Mystisk trippeldød - etterlatte med nytt krav\" href=\"https://www.dagbladet.no/nyheter/mystisk-trippeldod-etterlatte-med-nytt-krav/76134429\"><figure class=\"x__sc-1an7vu1-0 gtMzqw\"><picture><img data-defer=\"view\" title=\"Image: Mystisk trippeldød - etterlatte med nytt krav\" alt=\"Image: Mystisk trippeldød - etterlatte med nytt krav\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76061079&amp;panow=54.005167958656&amp;panoy=4.5871559633028&amp;panox=23.255813953488&amp;panoh=32.56880733945&amp;heightx=34.890965732087&amp;heightw=28.03738317757&amp;heighth=81.21546961326&amp;heighty=0&amp;width=402&amp;height=441\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Mystisk trippeldød -</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">etterlatte med nytt krav</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vil endre verneplikten\" href=\"https://www.dagbladet.no/nyheter/vil-endre-verneplikten/76127904\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Vil endre verneplikten\" alt=\"Image: Vil endre verneplikten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76095597&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iEukpb title dynamic-sizing\">Vil endre</span><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">verneplikten</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=\"Blodpropp: Disse er mest utsatt\" href=\"https://www.dagbladet.no/tema/blodpropp-disse-er-mest-utsatt/76075030\"><figure class=\"x__sc-1an7vu1-0 kByDQu\"><picture><img data-defer=\"view\" title=\"Image: Blodpropp: Disse er mest utsatt\" alt=\"Image: Blodpropp: Disse er mest utsatt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76075098&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=170\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Blodpropp: Disse</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">er mest utsatt</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-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Uventet problem på nakendate\" href=\"https://www.dagbladet.no/video/intimt-problem-pa-nakendate/IiKSHxpA\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Uventet problem på nakendate\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76100114.jpg?imageId=76100114&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/11/ecfdf871-7012-40d1-a560-b83669ee2bb2/naked_caro_gif1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/11/ecfdf871-7012-40d1-a560-b83669ee2bb2/naked_caro_gif1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Uventet problem</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">på nakendate</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-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-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ikke si at hun tapte\" href=\"https://www.dagbladet.no/kjendis/ikke-si-at-hun-tapte/76134713\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Ikke si at hun tapte\" alt=\"Image: - Ikke si at hun tapte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76135673&amp;panox=5.4621848739496&amp;panow=88.655462184874&amp;panoh=20.168067226891&amp;panoy=15.966386554622&amp;heighty=2.7173913043478&amp;heightx=29.218106995885&amp;heightw=37.037037037037&amp;heighth=39.945652173913&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">- Ikke si</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">at hun tapte</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dukker opp i Netflix-serie\" href=\"https://www.dagbladet.no/kultur/dukker-opp-i-netflix-serie/76127143\"><figure class=\"x__sc-1an7vu1-0 gkOGzu\"><picture><img data-defer=\"view\" title=\"Image: Dukker opp i Netflix-serie\" alt=\"Image: Dukker opp i Netflix-serie\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76127833&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=289\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">Dukker opp i</span><span class=\"x__pt8tzk-0 gWsWwS title dynamic-sizing\">Netflix-serie</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører uvanlig kallenavn\" href=\"https://www.dagbladet.no/kjendis/avslorer-uvanlig-kallenavn/76136431\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Avslører uvanlig kallenavn\" alt=\"Image: Avslører uvanlig kallenavn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76100700&amp;panoy=7.201646090535&amp;panow=97.222222222222&amp;panoh=14.639175257732&amp;panox=0.92592592592593&amp;heighty=4.4354838709677&amp;heightx=11.711711711712&amp;heightw=81.081081081081&amp;heighth=59.036144578313&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">Avslører uvanlig</span><span class=\"x__pt8tzk-0 ldTjgH title dynamic-sizing\">kallenavn</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Freser mot Ulvang-forslag\" href=\"https://www.dagbladet.no/sport/freser-mot-ulvang-forslag/76135862\"><figure class=\"x__sc-1an7vu1-0 ldkMOS\"><picture><img data-defer=\"view\" title=\"Image: Freser mot Ulvang-forslag\" alt=\"Image: Freser mot Ulvang-forslag\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76135882&amp;panoy=7.4829931972789&amp;panox=28.421052631579&amp;panow=43.793859789474&amp;panoh=24.156746258503&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=250\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">Freser mot</span><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Ulvang-forslag</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model-manual\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Omringes - så skjer dette\" href=\"https://www.dagbladet.no/video/omringer-bjornen-sa-skjer-dette/eLDE0Twg\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Omringes - så skjer dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76130965.jpg?imageId=76130965&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/01/11/31fcbf96-b5d1-4932-aca5-554a8b82ba0c/bjoern_vs_ulv_3_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/01/11/31fcbf96-b5d1-4932-aca5-554a8b82ba0c/bjoern_vs_ulv_3_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Omringes - så</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">skjer dette</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ned 40 kilo på 120 dager\" href=\"https://www.dagbladet.no/tema/suksessoppskrift-halverte-fettprosenten/75686038\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ned 40 kilo på 120 dager\" alt=\"Image: Ned 40 kilo på 120 dager\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75931895&amp;panoy=19.526627218935&amp;panox=0&amp;panow=99.528219047619&amp;panoh=42.017313609467&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Ned 40 kilo</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">på 120 dager</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Derfor vil hun ikke ha barn\" href=\"https://www.dagbladet.no/kjendis/derfor-vil-hun-ikke-ha-barn/76131050\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Derfor vil hun ikke ha barn\" alt=\"Image: Derfor vil hun ikke ha barn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75190688&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=19.285714285714&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">Derfor vil hun</span><span class=\"x__pt8tzk-0 kukeCs title dynamic-sizing\">ikke ha barn</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ble robbet\" href=\"https://www.dagbladet.no/kjendis/ble-robbet/76137810\"><figure class=\"x__sc-1an7vu1-0 btjLaZ\"><picture><img data-defer=\"view\" title=\"Image: Ble robbet\" alt=\"Image: Ble robbet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76137862&amp;panoy=4.3343653250774&amp;panox=0&amp;panow=100&amp;panoh=21.981424148607&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=391\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">Ble robbet</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ropte «æsj!» til Magnus i barnetoget\" href=\"https://www.dagbladet.no/nyheter/ropte-aesj-til-magnus-i-barnetoget/76126984\"><figure class=\"x__sc-1an7vu1-0 gikwvT\"><picture><img data-defer=\"view\" title=\"Image: - Ropte «æsj!» til Magnus i barnetoget\" alt=\"Image: - Ropte «æsj!» til Magnus i barnetoget\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76127261&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=488\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gLHLEv title dynamic-sizing\">- Ropte «æsj!» til</span><span class=\"x__pt8tzk-0 itkiNJ title dynamic-sizing\">Magnus i barnetoget</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skal være avslørt\" href=\"https://www.dagbladet.no/kjendis/skal-vaere-avslort/76129947\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Skal være avslørt\" alt=\"Image: Skal være avslørt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76129959&amp;panoy=30.714285714286&amp;panow=100&amp;panoh=50.714285714286&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">Skal være</span><span class=\"x__pt8tzk-0 flLVjk title dynamic-sizing\">avslørt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer om sterke bilder\" href=\"https://www.dagbladet.no/video/advarer-om-sterke-bilder/4ZLU4nDs\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advarer om sterke bilder\" alt=\"Image: Advarer om sterke bilder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/4ZLU4nDs-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Advarer om</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">sterke bilder</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=\"Test: Klarer du båtførerprøven?\" href=\"https://www.dagbladet.no/tema/test-deg-selv-klarer-du-batforerproven/76086480\"><figure class=\"x__sc-1an7vu1-0 GzIqd\"><picture><img data-defer=\"view\" title=\"Image: Test: Klarer du båtførerprøven?\" alt=\"Image: Test: Klarer du båtførerprøven?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76086571&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=320&amp;height=187\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">Test: Klarer du</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">båtførerprøven?</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører forlovelse\" href=\"https://www.dagbladet.no/kjendis/avslorer-forlovelse/76138562\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Avslører forlovelse\" alt=\"Image: Avslører forlovelse\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76138558&amp;panoh=21.981424148607&amp;panoy=5.8823529411765&amp;panox=0&amp;panow=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dA-Dohz title dynamic-sizing\">Avslører</span><span class=\"x__pt8tzk-0 hjGKKq title dynamic-sizing\">forlovelse</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Den siste turen\" href=\"https://www.dagbladet.no/kjendis/den-siste-turen/76127860\"><figure class=\"x__sc-1an7vu1-0 gzJWxx\"><picture><img data-defer=\"view\" title=\"Image: - Den siste turen\" alt=\"Image: - Den siste turen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76127887&amp;panow=100&amp;panoh=26.996197718631&amp;panoy=33.079847908745&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=410\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">- Den siste turen</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Frykter enorm miljøkatastrofe\" href=\"https://www.dagbladet.no/nyheter/frykter-enorm-miljokatastrofe/76130244\"><figure class=\"x__sc-1an7vu1-0 jAXojA\"><picture><img data-defer=\"view\" title=\"Image: Frykter enorm miljøkatastrofe\" alt=\"Image: Frykter enorm miljøkatastrofe\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76130293&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=266\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">Frykter enorm</span><span class=\"x__pt8tzk-0 lplqa-d title dynamic-sizing\">miljøkatastrofe</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kritiserte Russland-strategi - snudde over natta\" href=\"https://www.dagbladet.no/nyheter/kritiserte-russland-strategi-snudde-over-natta/76134147\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Kritiserte Russland-strategi - snudde over natta\" alt=\"Image: Kritiserte Russland-strategi - snudde over natta\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76134282&amp;panoy=3.3898305084746&amp;panox=0&amp;panow=100&amp;panoh=60.169491525424&amp;heighty=13.333333333333&amp;heightw=24.128686327078&amp;heighth=70&amp;heightx=37.533512064343&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">Kritiserte Russland-strategi</span><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">- snudde over natta</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Oda (25) kvitt angsten i superfart\" href=\"https://www.dagbladet.no/tema/oda-kvitt-angsten-i-superfart/75845502\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Oda (25) kvitt angsten i superfart\" alt=\"Image: Oda (25) kvitt angsten i superfart\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76024089&amp;panox=0&amp;panow=100&amp;panoh=41.520467836257&amp;panoy=19.298245614035&amp;heightw=50&amp;heighty=0&amp;heightx=21.111111111111&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Oda (25) kvitt</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">angsten i superfart</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ser kjærestene ha sex på TV\" href=\"https://www.dagbladet.no/video/ser-kjaerestene-ha-sex-pa-tv/6TxKaDhW\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ser kjærestene ha sex på TV\" alt=\"Image: Ser kjærestene ha sex på TV\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/6TxKaDhW-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">Ser kjærestene</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">ha sex på TV</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Tok 13 000 kroner for en bunt\" href=\"https://www.dagbladet.no/nyheter/tok-13-000-kroner-for-en-bunt/76129726\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Tok 13 000 kroner for en bunt\" alt=\"Image: - Tok 13 000 kroner for en bunt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76129777&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">- Tok 13 000</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">kroner for en bunt</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dramatisk politijakt: - Måtte stoppes\" href=\"https://www.dagbladet.no/nyheter/dramatisk-politijakt-matte-stoppes/76136110\"><figure class=\"x__sc-1an7vu1-0 krHhho\"><picture><img data-defer=\"view\" title=\"Image: Dramatisk politijakt: - Måtte stoppes\" alt=\"Image: Dramatisk politijakt: - Måtte stoppes\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76136262&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=262\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Dramatisk politijakt:</span><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">- Måtte stoppes</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Plutselig kommer oksen\" href=\"https://www.dagbladet.no/video/plutselig-kommer-oksen/hod6F17K\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Plutselig kommer oksen\" alt=\"Image: Plutselig kommer oksen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/hod6F17K-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">Plutselig</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">kommer oksen</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=\"Botox-behandlet: - Se på meg!\" href=\"https://www.dagbladet.no/tema/her-far-ana-46-nytt-ansikt/75784960\"><figure class=\"x__sc-1an7vu1-0 bqoCfD\"><picture><img data-defer=\"view\" title=\"Image: Botox-behandlet: - Se på meg!\" alt=\"Image: Botox-behandlet: - Se på meg!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75887409&amp;panow=100&amp;panoy=36.012861736334&amp;panox=0&amp;panoh=22.829581993569&amp;heighty=0&amp;heightw=90.909090909091&amp;heighth=100&amp;heightx=6.0606060606061&amp;width=320&amp;height=190\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Botox-behandlet:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">- Se på meg!</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-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-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Denne er sanksjonert: - Litt rart\" href=\"https://www.dagbladet.no/nyheter/denne-er-sanksjonert-litt-rart/76075599\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Denne er sanksjonert: - Litt rart\" alt=\"Image: Denne er sanksjonert: - Litt rart\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76130669&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\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Denne er sanksjonert:</span><span class=\"x__pt8tzk-0 gFDBEe title dynamic-sizing\">- Litt rart</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vil garantere for Sverige\" href=\"https://www.dagbladet.no/nyheter/vil-garantere-for-sverige/76137188\"><figure class=\"x__sc-1an7vu1-0 hWTYSx\"><picture><img data-defer=\"view\" title=\"Image: Vil garantere for Sverige\" alt=\"Image: Vil garantere for Sverige\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76138261&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=327\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">Vil garantere</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">for Sverige</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Unngå denne feilen: - Øker faren\" href=\"https://www.dagbladet.no/tema/unnga-denne-feilen-oker-faren/75942882\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Unngå denne feilen: - Øker faren\" alt=\"Image: Unngå denne feilen: - Øker faren\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75944060&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Unngå denne feilen:</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">- Øker faren</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=\"Skyter\" href=\"https://www.dagbladet.no/video/skyter/EtQEooXf\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Skyter\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/75060067.jpg?imageId=75060067&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/01/05/6c038ac8-0bea-4905-b0cb-24350e5ed870/elgangrep_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/01/05/6c038ac8-0bea-4905-b0cb-24350e5ed870/elgangrep_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hjGKKq title dynamic-sizing\">Skyter</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kommer ut av taket\" href=\"https://www.dagbladet.no/video/video-av-taket-gar-viralt-/CLxRhOnW\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Kommer ut av taket\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76114411.jpg?imageId=76114411&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/16/2b44ed55-dac9-4578-b64d-6eedc962396d/tak_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/16/2b44ed55-dac9-4578-b64d-6eedc962396d/tak_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jIyTDK title dynamic-sizing\">Kommer ut</span><span class=\"x__pt8tzk-0 fFAiTK title dynamic-sizing\">av taket</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=\"Akilles: De beste øvelsene\" href=\"https://www.dagbladet.no/tema/akilles-de-beste-ovelsene/75894826\"><figure class=\"x__sc-1an7vu1-0 fdycFS\"><picture><img data-defer=\"view\" title=\"Image: Akilles: De beste øvelsene\" alt=\"Image: Akilles: De beste øvelsene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75951245&amp;panoy=48.571428571429&amp;panox=0&amp;panow=100&amp;panoh=33.809523809524&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=320&amp;height=200\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dHKjeh title dynamic-sizing\">Akilles: De</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">beste øvelsene</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-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-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Mann drept i pensjonist-paradis\" href=\"https://www.dagbladet.no/nyheter/mann-drept-i-pensjonist-paradis/76127293\"><figure class=\"x__sc-1an7vu1-0 dDJbiB\"><picture><img data-defer=\"view\" title=\"Image: Mann drept i pensjonist-paradis\" alt=\"Image: Mann drept i pensjonist-paradis\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76127553&amp;panox=0&amp;panow=92.544268406337&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=92.544268406337&amp;heighth=100&amp;width=485&amp;height=326\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">Mann drept i</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">pensjonist-paradis</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Går mot Johaug-råd\" href=\"https://www.dagbladet.no/sport/gar-mot-johaug-rad/76128353\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Går mot Johaug-råd\" alt=\"Image: Går mot Johaug-råd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76128878&amp;panoy=7.8571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightx=31.674208144796&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 egjpuh title dynamic-sizing\">Går mot</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">Johaug-råd</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Første date? Vinner-spørsmålene\" href=\"https://www.dagbladet.no/tema/ni-vinner-sporsmaltil-forste-date/76025347\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Første date? Vinner-spørsmålene\" alt=\"Image: Første date? Vinner-spørsmålene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76129220&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Første date?</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Vinner-spørsmålene</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sjanseløs\" href=\"https://www.dagbladet.no/video/jafser-til-faller-uti/whHTxr8r\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Sjanseløs\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76126980.jpg?imageId=76126980&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/18/f6afee64-ee18-40fe-913f-3e33085de8f8/hai_biter_brett_gif_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/18/f6afee64-ee18-40fe-913f-3e33085de8f8/hai_biter_brett_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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">Sjanseløs</span></h3></header></a></article></div></div><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-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=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Eit fattig folk reiser seg\" href=\"https://www.dagbladet.no/meninger/eit-fattig-folk-reiser-seg/76111926\"><figure class=\"x__sc-1an7vu1-0 gSabaN\"><picture><img data-defer=\"view\" title=\"Image: Eit fattig folk reiser seg\" alt=\"Image: Eit fattig folk reiser seg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76112455&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=40.540540540541&amp;heighth=100&amp;heightx=32.882882882883&amp;width=402&amp;height=449\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bpsQVB title dynamic-sizing\">Eit fattig</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">folk reiser seg</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dritten i midten\" href=\"https://www.dagbladet.no/meninger/motoren-i-nord/76128660\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dritten i midten\" alt=\"Image: Dritten i midten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76115243&amp;panow=57.534246575342&amp;panoh=29.098360655738&amp;panoy=27.049180327869&amp;panox=14.246575342466&amp;heightw=23.936170212766&amp;heighth=58.8&amp;heighty=16.8&amp;heightx=25&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dqFtBy title dynamic-sizing\">Dritten</span><span class=\"x__pt8tzk-0 hXgjw title dynamic-sizing\">i midten</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Må tenke kjapt\" href=\"https://www.dagbladet.no/video/kat-hjort-misforstar/sB3P5EZg\"><figure class=\"x__sc-1an7vu1-0 jOMhbl moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Må tenke kjapt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76130383.jpg?imageId=76130383&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=244\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/18/7dc034a3-48ab-4e57-9843-7bb1188b271a/elk_gif_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/18/7dc034a3-48ab-4e57-9843-7bb1188b271a/elk_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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Må tenke kjapt</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=\"- Nytt liv med cannabis\" href=\"https://www.dagbladet.no/nyheter/nytt-liv-med-cannabis/75785623\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Nytt liv med cannabis\" alt=\"Image: - Nytt liv med cannabis\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75785744&amp;panoy=22.517391304348&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;heighty=0&amp;heightx=20.434782608696&amp;heightw=40.869565217391&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iVreMl title dynamic-sizing\">- Nytt liv</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">med cannabis</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-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-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Definitivt barn i framtida\" href=\"https://www.dagbladet.no/kjendis/definitivt-barn-i-framtida/76111749\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Definitivt barn i framtida\" alt=\"Image: - Definitivt barn i framtida\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76112565&amp;panoy=7.1428571428571&amp;panow=100&amp;panoh=50.714285714286&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jCkLvS title dynamic-sizing\">- Definitivt</span><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">barn i framtida</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Hadde hjernesvulst\" href=\"https://www.dagbladet.no/nyheter/hadde-hjernesvulst/76115436\"><figure class=\"x__sc-1an7vu1-0 JFmgR\"><picture><img data-defer=\"view\" title=\"Image: Hadde hjernesvulst\" alt=\"Image: Hadde hjernesvulst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=76115762&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=439\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">Hadde hjernesvulst</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gitaristen ber om unnskyldning\" href=\"https://www.dagbladet.no/kultur/gitaristen-ber-om-unnskyldning/75719154\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Gitaristen ber om unnskyldning\" alt=\"Image: Gitaristen ber om unnskyldning\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75848448&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=25.639290252708&amp;panoy=20.57761732852&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Gitaristen ber</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">om unnskyldning</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=\"Advares - så hopper han\" href=\"https://www.dagbladet.no/video/advares-sa-hopper-han/lC77Gc57\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advares - så hopper han\" alt=\"Image: Advares - så hopper han\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/lC77Gc57-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Advares - så</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">hopper han</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-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=\"Slått ut: - Grusomt\" href=\"https://www.dagbladet.no/video/slatt-ut-av-reservelaget-grusomt/R3gwQ8NX\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Slått ut: - Grusomt\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/76106096.jpg?imageId=76106096&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/05/12/58812e1e-026e-4f4e-aa41-69c08de48106/gif_keeper_9912.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/05/12/58812e1e-026e-4f4e-aa41-69c08de48106/gif_keeper_9912.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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jwrbOd title dynamic-sizing\">Slått ut:</span><span class=\"x__pt8tzk-0 dLwqhJ title dynamic-sizing\">- Grusomt</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=\"Barnelegens effektive medisin mot astma\" href=\"https://www.dagbladet.no/tema/barnelegens-effektive-medisin-mot-astma/75783387\"><figure class=\"x__sc-1an7vu1-0 hWqjha\"><picture><img data-defer=\"view\" title=\"Image: Barnelegens effektive medisin mot astma\" alt=\"Image: Barnelegens effektive medisin mot astma\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75863942&amp;panoy=24.651162790698&amp;panow=67.91520623053&amp;panoh=34.422238139535&amp;panox=7.1651090342679&amp;heighty=0.005105882352942&amp;heightx=20.861965065502&amp;heightw=41.05144628821&amp;heighth=100.00510588235&amp;width=320&amp;height=248\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Barnelegens effektive</span><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">medisin mot astma</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-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\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Trippeltest: Hvilken slår ID3?\" href=\"https://www.dagbladet.no/tema/trippeltest-hvilken-slar-id3/75907218\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Trippeltest: Hvilken slår ID3?\" alt=\"Image: Trippeltest: Hvilken slår ID3?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75924803&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightw=44.16667&amp;heighty=0.46619580419581&amp;heighth=99.533804195804&amp;heightx=40&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Trippeltest:</span><span class=\"x__pt8tzk-0 gjHDge title dynamic-sizing\">Hvilken slår ID3?</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=\"Klippet «alle» snakker om\" href=\"https://www.dagbladet.no/video/klippet-alle-snakker-om/qfWVwjT4\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Klippet «alle» snakker om\" alt=\"Image: Klippet «alle» snakker om\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/qfWVwjT4-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Klippet «alle»</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">snakker om</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Usikker på forholdet: - Mye krangling\" href=\"https://www.dagbladet.no/video/usikker-pa-forholdet-mye-krangling/AkIlVwmL\"><figure class=\"x__sc-1an7vu1-0 lmdjnV\"><picture><img data-defer=\"view\" title=\"Image: Usikker på forholdet: - Mye krangling\" alt=\"Image: Usikker på forholdet: - Mye krangling\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/AkIlVwmL-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Usikker på forholdet:</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">- Mye krangling</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=\"Lege: Ny hjelp mot stoffskifte\" href=\"https://www.dagbladet.no/tema/lege-ny-hjelp-mot-lavt-stoffskifte/75758096\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Lege: Ny hjelp mot stoffskifte\" alt=\"Image: Lege: Ny hjelp mot stoffskifte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75764096&amp;panow=100&amp;panoh=36.979166666667&amp;panox=0&amp;panoy=19.270833333333&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Lege: Ny hjelp</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">mot stoffskifte</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-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 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=\"Mister avtale etter skandalescener\" href=\"https://www.dagbladet.no/video/mister-avtale-etter-skandalescener/YUPzH4QI\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Mister avtale etter skandalescener\" alt=\"Image: Mister avtale etter skandalescener\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/YUPzH4QI-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Mister avtale etter</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">skandalescener</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=\"Hudleger: Beste behandling mot utslett\" href=\"https://www.dagbladet.no/tema/hudleger-beste-behandling-mot-utslett/75990633\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Hudleger: Beste behandling mot utslett\" alt=\"Image: Hudleger: Beste behandling mot utslett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75990809&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Hudleger: Beste</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">behandling</span><span class=\"x__pt8tzk-0 jIyTDK title dynamic-sizing\">mot utslett</span></h3></header></a></article></div></div><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard12&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Verste jeg har sett\" href=\"https://www.dagbladet.no/video/-verste-jeg-har-sett/hHABkFeO\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Verste jeg har sett\" alt=\"Image: - Verste jeg har sett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/hHABkFeO-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jFsmoq title dynamic-sizing\">- Verste</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">jeg har sett</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=\"Dronningens venn: Skjulte grusom hemmelighet\" href=\"https://www.dagbladet.no/nyheter/dronningens-venn-skjulte-grusom-hemmelighet/75892960\"><figure class=\"x__sc-1an7vu1-0 gjAolr\"><picture><img data-defer=\"view\" title=\"Image: Dronningens venn: Skjulte grusom hemmelighet\" alt=\"Image: Dronningens venn: Skjulte grusom hemmelighet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=75893012&amp;panox=0&amp;panow=99.528219047619&amp;panoh=79.785685393258&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=172\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></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>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Dronningens venn:</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">Skjulte grusom</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">hemmelighet</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div>"]
lukk
dagbladet er en del av Aller Media
Hvorfor ser du denne annonsen
Nettstedet du nå besøker blir i stor del finansiert av annonseinntekter. Basert på din tidligere aktivitet hos oss, vil du få annonser vi tror kan interessere deg.
Du velger selv om du ønsker å endre dine innstillinger
Om Aller Media og annonsering
Aller Media eier nettstedene Dagbladet, Sol, DinSide, KK, Se og Hør, Lommelegen, Topp og Vi
Vi bryr oss om ditt personvern
dagbladet er en del av Aller Media, som er ansvarlig for dine data. Vi
bruker dataene til å forbedre og tilpasse tjenestene, tilbudene og annonsene
våre.
Vil du vite mer om hvordan du kan endre dine innstillinger, gå til
personverninnstillinger