["<style>.fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .dFQuBj.dFQuBj.dFQuBj.dFQuBj{height:0;padding-bottom:66.59%;}/*!sc*/ .jjcUMQ.jjcUMQ.jjcUMQ.jjcUMQ{height:0;padding-bottom:58.35%;}/*!sc*/ .bdwfCl.bdwfCl.bdwfCl.bdwfCl{height:0;padding-bottom:59.68%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .gtMzqw.gtMzqw.gtMzqw.gtMzqw{height:0;padding-bottom:109.7%;}/*!sc*/ .lfAzpK.lfAzpK.lfAzpK.lfAzpK{height:0;padding-bottom:93.03%;}/*!sc*/ .edsdSp.edsdSp.edsdSp.edsdSp{height:0;padding-bottom:57.73%;}/*!sc*/ .ifbRza.ifbRza.ifbRza.ifbRza{height:0;padding-bottom:86.56%;}/*!sc*/ .cNDCDb.cNDCDb.cNDCDb.cNDCDb{height:0;padding-bottom:72.81%;}/*!sc*/ .bicgip.bicgip.bicgip.bicgip{height:0;padding-bottom:89.07%;}/*!sc*/ .dwEuyS.dwEuyS.dwEuyS.dwEuyS{height:0;padding-bottom:65.42%;}/*!sc*/ .jbNkVD.jbNkVD.jbNkVD.jbNkVD{height:0;padding-bottom:119.9%;}/*!sc*/ .kkbWxc.kkbWxc.kkbWxc.kkbWxc{height:0;padding-bottom:97.18%;}/*!sc*/ .fdycFS.fdycFS.fdycFS.fdycFS{height:0;padding-bottom:62.5%;}/*!sc*/ .fUGaTG.fUGaTG.fUGaTG.fUGaTG{height:0;padding-bottom:92.53%;}/*!sc*/ .dkrHKM.dkrHKM.dkrHKM.dkrHKM{height:0;padding-bottom:53.81%;}/*!sc*/ .jBjOhG.jBjOhG.jBjOhG.jBjOhG{height:0;padding-bottom:51.67%;}/*!sc*/ .eIlDNY.eIlDNY.eIlDNY.eIlDNY{height:0;padding-bottom:51.56%;}/*!sc*/ .jVuBDT.jVuBDT.jVuBDT.jVuBDT{height:0;padding-bottom:58.14%;}/*!sc*/ .kMOLOX.kMOLOX.kMOLOX.kMOLOX{height:0;padding-bottom:79.17%;}/*!sc*/ .dsoRmW.dsoRmW.dsoRmW.dsoRmW{height:0;padding-bottom:120.39%;}/*!sc*/ .UytSm.UytSm.UytSm.UytSm{height:0;padding-bottom:81.59%;}/*!sc*/ .gYoHKl.gYoHKl.gYoHKl.gYoHKl{height:0;padding-bottom:55.31%;}/*!sc*/ .eWEEkc.eWEEkc.eWEEkc.eWEEkc{height:0;padding-bottom:51.34%;}/*!sc*/ .iBoTJJ.iBoTJJ.iBoTJJ.iBoTJJ{height:0;padding-bottom:75.62%;}/*!sc*/ .gmpxUf.gmpxUf.gmpxUf.gmpxUf{height:0;padding-bottom:55.62%;}/*!sc*/ .beBWtS.beBWtS.beBWtS.beBWtS{height:0;padding-bottom:55.67%;}/*!sc*/ .jFHrOt.jFHrOt.jFHrOt.jFHrOt{height:0;padding-bottom:85.07%;}/*!sc*/ .jBzAwk.jBzAwk.jBzAwk.jBzAwk{height:0;padding-bottom:56.08%;}/*!sc*/ .dGSQcf.dGSQcf.dGSQcf.dGSQcf{height:0;padding-bottom:71.64%;}/*!sc*/ .kHDOtO.kHDOtO.kHDOtO.kHDOtO{height:0;padding-bottom:78.75%;}/*!sc*/ .evkaIe.evkaIe.evkaIe.evkaIe{height:0;padding-bottom:70.64%;}/*!sc*/ .fpylwJ.fpylwJ.fpylwJ.fpylwJ{height:0;padding-bottom:88.75%;}/*!sc*/ .ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .iRrFGC.iRrFGC.iRrFGC.iRrFGC{height:0;padding-bottom:54.37%;}/*!sc*/ .gkSegO.gkSegO.gkSegO.gkSegO{height:0;padding-bottom:65.93%;}/*!sc*/ data-styled.g367[id=\"x__sc-1an7vu1-0\"]{content:\"fjJyvE,fnQDHb,dFQuBj,jjcUMQ,bdwfCl,kviAry,gtMzqw,lfAzpK,edsdSp,ifbRza,cNDCDb,bicgip,dwEuyS,jbNkVD,kkbWxc,fdycFS,fUGaTG,dkrHKM,jBjOhG,eIlDNY,jVuBDT,kMOLOX,dsoRmW,UytSm,gYoHKl,eWEEkc,iBoTJJ,gmpxUf,beBWtS,jFHrOt,jBzAwk,dGSQcf,kHDOtO,evkaIe,fpylwJ,ejnyBo,iRrFGC,gkSegO,\"}/*!sc*/ .dbonoY.dbonoY.dbonoY.dbonoY{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.dbonoY.dbonoY.dbonoY.dbonoY{font-size:2em!important;}}/*!sc*/ .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*/ .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*/ .kNAQKA.kNAQKA.kNAQKA.kNAQKA{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kNAQKA.kNAQKA.kNAQKA.kNAQKA{font-size:1.9em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .eQgupK.eQgupK.eQgupK.eQgupK{font-size:8.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQgupK.eQgupK.eQgupK.eQgupK{font-size:3em!important;}}/*!sc*/ .kauVAS.kauVAS.kauVAS.kauVAS{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kauVAS.kauVAS.kauVAS.kauVAS{font-size:2.1em!important;}}/*!sc*/ .dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:1.9em!important;}}/*!sc*/ .cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:0.8em!important;}}/*!sc*/ .frzFun.frzFun.frzFun.frzFun{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.frzFun.frzFun.frzFun.frzFun{font-size:0.9em!important;}}/*!sc*/ .dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:1.2em!important;}}/*!sc*/ .jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:1.1em!important;}}/*!sc*/ .cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnaKkM.cnaKkM.cnaKkM.cnaKkM{font-size:0.9em!important;}}/*!sc*/ .hlBrXM.hlBrXM.hlBrXM.hlBrXM{font-size:10em!important;}/*!sc*/ @media only screen and (max-width:640px){.hlBrXM.hlBrXM.hlBrXM.hlBrXM{font-size:3.6em!important;}}/*!sc*/ .epoJzD.epoJzD.epoJzD.epoJzD{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.epoJzD.epoJzD.epoJzD.epoJzD{font-size:1.1em!important;}}/*!sc*/ .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*/ .bvsVFh.bvsVFh.bvsVFh.bvsVFh{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvsVFh.bvsVFh.bvsVFh.bvsVFh{font-size:2.5em!important;}}/*!sc*/ .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*/ .jxnmov.jxnmov.jxnmov.jxnmov{font-size:9.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jxnmov.jxnmov.jxnmov.jxnmov{font-size:3.3em!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*/ .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*/ .dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:1.6em!important;}}/*!sc*/ .fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:0.9em!important;}}/*!sc*/ .dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.dPoeFo.dPoeFo.dPoeFo.dPoeFo{font-size:0.6em!important;}}/*!sc*/ .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*/ .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*/ .LzBnW.LzBnW.LzBnW.LzBnW{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.LzBnW.LzBnW.LzBnW.LzBnW{font-size:1.5em!important;}}/*!sc*/ .cVLSdA.cVLSdA.cVLSdA.cVLSdA{font-size:9em!important;}/*!sc*/ @media only screen and (max-width:640px){.cVLSdA.cVLSdA.cVLSdA.cVLSdA{font-size:3.2em!important;}}/*!sc*/ .fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:7.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:2.8em!important;}}/*!sc*/ .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*/ .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*/ .dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:0.6em!important;}}/*!sc*/ .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*/ .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*/ .inoUtg.inoUtg.inoUtg.inoUtg{font-size:8.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.inoUtg.inoUtg.inoUtg.inoUtg{font-size:3.1em!important;}}/*!sc*/ .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*/ .jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:6.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:2.4em!important;}}/*!sc*/ .gVRWAB.gVRWAB.gVRWAB.gVRWAB{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gVRWAB.gVRWAB.gVRWAB.gVRWAB{font-size:1.5em!important;}}/*!sc*/ .hjGKKq.hjGKKq.hjGKKq.hjGKKq{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.hjGKKq.hjGKKq.hjGKKq.hjGKKq{font-size:2.3em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .SXEmE.SXEmE.SXEmE.SXEmE{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.SXEmE.SXEmE.SXEmE.SXEmE{font-size:2.1em!important;}}/*!sc*/ .fqIxnw.fqIxnw.fqIxnw.fqIxnw{font-size:12em!important;}/*!sc*/ @media only screen and (max-width:640px){.fqIxnw.fqIxnw.fqIxnw.fqIxnw{font-size:4.3em!important;}}/*!sc*/ .iyrywY.iyrywY.iyrywY.iyrywY{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.iyrywY.iyrywY.iyrywY.iyrywY{font-size:1.8em!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*/ .bFQuDG.bFQuDG.bFQuDG.bFQuDG{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bFQuDG.bFQuDG.bFQuDG.bFQuDG{font-size:1.9em!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*/ .kLBvft.kLBvft.kLBvft.kLBvft{font-size:7.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kLBvft.kLBvft.kLBvft.kLBvft{font-size:2.6em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .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*/ .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*/ .ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:1.7em!important;}}/*!sc*/ .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*/ .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*/ .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*/ .dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:2em!important;}}/*!sc*/ .jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jFsmoq.jFsmoq.jFsmoq.jFsmoq{font-size:1.8em!important;}}/*!sc*/ .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*/ .iWZcdV.iWZcdV.iWZcdV.iWZcdV{font-size:9.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iWZcdV.iWZcdV.iWZcdV.iWZcdV{font-size:3.3em!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*/ .cGLrSG.cGLrSG.cGLrSG.cGLrSG{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cGLrSG.cGLrSG.cGLrSG.cGLrSG{font-size:1.6em!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*/ .XaoDC.XaoDC.XaoDC.XaoDC{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.XaoDC.XaoDC.XaoDC.XaoDC{font-size:2.1em!important;}}/*!sc*/ .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*/ .hQxAYP.hQxAYP.hQxAYP.hQxAYP{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.hQxAYP.hQxAYP.hQxAYP.hQxAYP{font-size:2em!important;}}/*!sc*/ .iLHueX.iLHueX.iLHueX.iLHueX{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iLHueX.iLHueX.iLHueX.iLHueX{font-size:1.6em!important;}}/*!sc*/ .iQrIZq.iQrIZq.iQrIZq.iQrIZq{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iQrIZq.iQrIZq.iQrIZq.iQrIZq{font-size:2.2em!important;}}/*!sc*/ .beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:0.6em!important;}}/*!sc*/ .bUEFlv.bUEFlv.bUEFlv.bUEFlv{font-size:1.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bUEFlv.bUEFlv.bUEFlv.bUEFlv{font-size:0.5em!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*/ .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*/ .wpWLG.wpWLG.wpWLG.wpWLG{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.wpWLG.wpWLG.wpWLG.wpWLG{font-size:1.2em!important;}}/*!sc*/ .kpDSmG.kpDSmG.kpDSmG.kpDSmG{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kpDSmG.kpDSmG.kpDSmG.kpDSmG{font-size:2em!important;}}/*!sc*/ .jPbWVE.jPbWVE.jPbWVE.jPbWVE{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jPbWVE.jPbWVE.jPbWVE.jPbWVE{font-size:1.8em!important;}}/*!sc*/ .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*/ .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*/ .jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:0.5em!important;}}/*!sc*/ .fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:1.5em!important;}}/*!sc*/ .kCKswK.kCKswK.kCKswK.kCKswK{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kCKswK.kCKswK.kCKswK.kCKswK{font-size:1.6em!important;}}/*!sc*/ .bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:1.4em!important;}}/*!sc*/ .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*/ .glOqqI.glOqqI.glOqqI.glOqqI{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.glOqqI.glOqqI.glOqqI.glOqqI{font-size:1.4em!important;}}/*!sc*/ .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*/ .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*/ .bHxiDg.bHxiDg.bHxiDg.bHxiDg{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bHxiDg.bHxiDg.bHxiDg.bHxiDg{font-size:1.6em!important;}}/*!sc*/ .ihkPAv.ihkPAv.ihkPAv.ihkPAv{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.ihkPAv.ihkPAv.ihkPAv.ihkPAv{font-size:0.8em!important;}}/*!sc*/ .jdgMzU.jdgMzU.jdgMzU.jdgMzU{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jdgMzU.jdgMzU.jdgMzU.jdgMzU{font-size:1em!important;}}/*!sc*/ data-styled.g368[id=\"x__pt8tzk-0\"]{content:\"dbonoY,bvXqXn,hrVcDN,kNAQKA,hbwikt,ctWqNs,kNhGgX,hsPeia,bxtuZJ,eQgupK,kauVAS,dfgvpn,cyVXzf,frzFun,dyaAfc,jEhvtw,cnaKkM,hlBrXM,epoJzD,bWSnVS,bvsVFh,wpfcp,jxnmov,jiGVVj,dfserP,dBWQRi,fNDhDy,dPoeFo,kukeCs,jGSTdz,LzBnW,cVLSdA,fZJFvq,jtCXvA,zWscE,dDKeDQ,itkiNJ,cFtCN,inoUtg,ldTjgH,jfcAvK,gVRWAB,hjGKKq,kVJNPR,eYoKgk,kMqJSM,SXEmE,fqIxnw,iyrywY,cZmotM,bFQuDG,Uccen,kLBvft,bwzwBX,iXjdLY,jdcGMN,gPIxea,kUqUJf,ftetSQ,iYgBvA,iFlEmK,bwGQrt,dWzMnA,jFsmoq,iKalhP,iWZcdV,lfBuL,cGLrSG,jfvMWJ,XaoDC,inksEV,hQxAYP,iLHueX,iQrIZq,beDNpZ,bUEFlv,iNHyie,eVBoHG,wpWLG,kpDSmG,jPbWVE,gWsWwS,tqGkg,jRIgeY,fTAjeM,kCKswK,bcCfuJ,kwLuaB,glOqqI,jIyTDK,fIeyCx,bHxiDg,ihkPAv,jdgMzU,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div id=\"apos-netboard3\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bildene «ingen» så\" href=\"https://www.dagbladet.no/video/bildene-ingen-sa-kvalme-oppi-halsen/pKYDdR99\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Bildene «ingen» så\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81338272.jpg?imageId=81338272&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/30/1e9bf81e-cdeb-44e3-961f-82fbf4fabbd0/gif_1_nordas_laur_3.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/30/1e9bf81e-cdeb-44e3-961f-82fbf4fabbd0/gif_1_nordas_laur_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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dbonoY title dynamic-sizing\">Bildene</span><span class=\"x__pt8tzk-0 bvXqXn title dynamic-sizing\">«ingen» så</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=\"- Jeg ble voldtatt\" href=\"https://www.dagbladet.no/kjendis/jeg-ble-voldtatt/81035724\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Jeg ble voldtatt\" alt=\"Image: - Jeg ble voldtatt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81209010&amp;panox=0.086579999999997&amp;panow=100.08658&amp;panoh=51.558441428571&amp;panoy=14.285714285714&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">- Jeg ble</span><span class=\"x__pt8tzk-0 kNAQKA title dynamic-sizing\">voldtatt</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Vi er dypt bekymret\" href=\"https://www.dagbladet.no/nyheter/vi-er-dypt-bekymret/81346442\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Vi er dypt bekymret\" alt=\"Image: - Vi er dypt bekymret\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81346449&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hbwikt title dynamic-sizing\">- Vi er dypt</span><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">bekymret</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Funnet død med pose over hodet\" href=\"https://www.dagbladet.no/nyheter/funnet-dod-med-pose-over-hodet/81342518\"><figure class=\"x__sc-1an7vu1-0 dFQuBj\"><picture><img data-defer=\"view\" title=\"Image: - Funnet død med pose over hodet\" alt=\"Image: - Funnet død med pose over hodet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81340744&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=323&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">- Funnet død med</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">pose over hodet</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nedslående beskjed\" href=\"https://www.dagbladet.no/sport/nedslaende-beskjed/81345914\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Nedslående beskjed\" alt=\"Image: Nedslående beskjed\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345919&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=17.857142857143&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">Nedslående</span><span class=\"x__pt8tzk-0 eQgupK title dynamic-sizing\">beskjed</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skjult hint: - Det sier alt\" href=\"https://www.dagbladet.no/kjendis/skjult-hint-det-sier-alt/81338783\"><figure class=\"x__sc-1an7vu1-0 jjcUMQ\"><picture><img data-defer=\"view\" title=\"Image: Skjult hint: - Det sier alt\" alt=\"Image: Skjult hint: - Det sier alt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339822&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kauVAS title dynamic-sizing\">Skjult hint:</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">- Det sier alt</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=\"Supergrepene mot neglesopp: Billig og effektivt!\" href=\"https://www.dagbladet.no/tema/supergrepene-mot-neglesopp-billig-og-effektivt/81328715\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Supergrepene mot neglesopp: Billig og effektivt!\" alt=\"Image: Supergrepene mot neglesopp: Billig og effektivt!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335659&amp;panoy=15.328467153285&amp;panox=0&amp;panow=100&amp;panoh=51.094890510949&amp;heightw=40.93023255814&amp;heighth=100&amp;heightx=3.7209302325581&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Supergrepene mot</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">neglesopp: Billig</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">og effektivt!</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-black\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Drept av den russiske hæren\" href=\"https://www.dagbladet.no/video/-gi-meg-levningene-hans/QNYKShXP\"><figure class=\"x__sc-1an7vu1-0 bdwfCl moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Drept av den russiske hæren\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81340351.jpg?imageId=81340351&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=191\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/28/a10a8f80-5b56-4fb7-b877-a084ee5359af/bentley_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/28/a10a8f80-5b56-4fb7-b877-a084ee5359af/bentley_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Drept av den</span><span class=\"x__pt8tzk-0 cnaKkM title dynamic-sizing\">russiske hæren</span></h3></header></a></article><div id=\"apos-medium-rectangle3\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Funn av død person\" href=\"https://www.dagbladet.no/nyheter/funn-av-dod-person/81345229\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Funn av død person\" alt=\"Image: Funn av død person\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345491&amp;panox=0.4739336492891&amp;panoy=15.107913669065&amp;panow=99.526066350711&amp;panoh=51.079136690647&amp;heightx=26.666666666667&amp;heightw=40&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hlBrXM title dynamic-sizing\">Funn av</span><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">død person</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Snikfilmet på do: Lekket på nett\" href=\"https://www.dagbladet.no/nyheter/snikfilmet-pa-do-lekket-pa-nett/81342675\"><figure class=\"x__sc-1an7vu1-0 gtMzqw\"><picture><img data-defer=\"view\" title=\"Image: Snikfilmet på do: Lekket på nett\" alt=\"Image: Snikfilmet på do: Lekket på nett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343262&amp;panow=100&amp;panoh=84.69696969697&amp;panox=0&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=84.69696969697&amp;width=402&amp;height=441&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Snikfilmet på do:</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Lekket på nett</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Trussel under Moskva\" href=\"https://www.dagbladet.no/nyheter/trussel-under-moskva/81341347\"><figure class=\"x__sc-1an7vu1-0 lfAzpK\"><picture><img data-defer=\"view\" title=\"Image: Trussel under Moskva\" alt=\"Image: Trussel under Moskva\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341473&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=374&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bvsVFh title dynamic-sizing\">Trussel</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">under Moskva</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Døde etter maraton\" href=\"https://www.dagbladet.no/kjendis/dode-etter-maraton/81340262\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Døde etter maraton\" alt=\"Image: Døde etter maraton\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81340479&amp;panoy=26.515151515152&amp;panox=0&amp;panow=99.842766981132&amp;panoh=27.525252272727&amp;heightw=77.030811764706&amp;heighth=99.77628590604&amp;heighty=0&amp;heightx=15.126050420168&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 wpfcp title dynamic-sizing\">Døde etter</span><span class=\"x__pt8tzk-0 jxnmov title dynamic-sizing\">maraton</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Martins (71) demens-grep: Helt frisk\" href=\"https://www.dagbladet.no/tema/martins-71-demens-grep-helt-frisk/81274253\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Martins (71) demens-grep: Helt frisk\" alt=\"Image: Martins (71) demens-grep: Helt frisk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81274882&amp;panoy=27.542372881356&amp;panox=0&amp;panow=100&amp;panoh=30.084745762712&amp;heightw=61.224489795918&amp;heighth=88.55421686747&amp;heighty=5.421686746988&amp;heightx=21.08843537415&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Martins (71)</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">demens-grep:</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">Helt frisk</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=\"Brutale kamper: - Mistet flere brigader\" href=\"https://www.dagbladet.no/video/brutale-kamper-mistet-flere-brigader/kAkEx7tx\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Brutale kamper: - Mistet flere brigader\" alt=\"Image: Brutale kamper: - Mistet flere brigader\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kAkEx7tx-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Brutale kamper:</span><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">- Mistet flere brigader</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Hva faen feiler det folk?\" href=\"https://www.dagbladet.no/nyheter/hva-faen-feiler-det-folk/81344286\"><figure class=\"x__sc-1an7vu1-0 edsdSp\"><picture><img data-defer=\"view\" title=\"Image: - Hva faen feiler det folk?\" alt=\"Image: - Hva faen feiler det folk?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81344463&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=280&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kukeCs title dynamic-sizing\">- Hva faen</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">feiler det folk?</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sønnen vekker oppsikt\" href=\"https://www.dagbladet.no/kjendis/sonnen-vekker-oppsikt/81334220\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Sønnen vekker oppsikt\" alt=\"Image: Sønnen vekker oppsikt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81331485&amp;panoy=13.913043478261&amp;panox=0&amp;panow=100&amp;panoh=30.869565217391&amp;heightw=100&amp;heighty=0&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Sønnen vekker</span><span class=\"x__pt8tzk-0 cVLSdA title dynamic-sizing\">oppsikt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Reagerer: - Det er en ære\" href=\"https://www.dagbladet.no/kjendis/reagerer-det-er-en-aere/81337569\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Det er en ære\" alt=\"Image: Reagerer: - Det er en ære\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338362&amp;panoy=25.764192139738&amp;panox=0&amp;panow=99.842766981132&amp;panoh=15.866084279476&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fZJFvq title dynamic-sizing\">Reagerer:</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">- Det er en ære</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Deler detaljer fra sexlivet\" href=\"https://www.dagbladet.no/kjendis/deler-detaljer-fra-sexlivet/81342175\"><figure class=\"x__sc-1an7vu1-0 ifbRza\"><picture><img data-defer=\"view\" title=\"Image: Deler detaljer fra sexlivet\" alt=\"Image: Deler detaljer fra sexlivet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342786&amp;panow=99.842766981132&amp;panoh=34.276729245283&amp;panoy=6.6037735849057&amp;panox=0&amp;heighty=0&amp;heightx=4.6979865771812&amp;heightw=61.521252348993&amp;heighth=99.77628590604&amp;width=402&amp;height=348&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">Deler detaljer</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">fra sexlivet</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advokat: Styr unna framtidsfullmakt-fella \" href=\"https://www.dagbladet.no/tema/advokat-styr-unna-framtidsfullmakt-fella/81077382\"><figure class=\"x__sc-1an7vu1-0 cNDCDb\"><picture><img data-defer=\"view\" title=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" alt=\"Image: Advokat: Styr unna framtidsfullmakt-fella \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81242728&amp;panoy=16.551724137931&amp;panox=0.083402752293575&amp;panow=100.08340275229&amp;panoh=51.159874482759&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=320&amp;height=233&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Advokat: Styr unna</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">framtidsfullmakt-fella </span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 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=\"147 passasjerer - hopper av\" href=\"https://www.dagbladet.no/video/havner-pa-feil-spor/pD7oQkXI\"><figure class=\"x__sc-1an7vu1-0 bdwfCl moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: 147 passasjerer - hopper av\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81338982.jpg?imageId=81338982&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=191\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/30/a5384927-be98-407b-9565-d61329501c75/gif3.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/30/a5384927-be98-407b-9565-d61329501c75/gif3.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 itkiNJ title dynamic-sizing\">147 passasjerer</span><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">- hopper av</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=\"Gjør et kjempekupp hos Tights.no\" href=\"https://tinyurl.com/tightsdirekte?allerID=1202604264\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Gjør et kjempekupp hos Tights.no\" alt=\"Image: Gjør et kjempekupp hos Tights.no\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81274056.jpg?imageId=81274056&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Gjør et kjempekupp</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">hos Tights.no</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Måper: - Galskap\" href=\"https://www.dagbladet.no/sport/maper-galskap/81342119\"><figure class=\"x__sc-1an7vu1-0 bicgip\"><picture><img data-defer=\"view\" title=\"Image: Måper: - Galskap\" alt=\"Image: Måper: - Galskap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342192&amp;panow=81.395348837209&amp;panoh=41.279069767442&amp;panoy=37.209302325581&amp;panox=0&amp;heighty=13.068181818182&amp;heightx=30.30303030303&amp;heightw=34.090909090909&amp;heighth=83.522727272727&amp;width=485&amp;height=432&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Måper: - Galskap</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avviser vennskap\" href=\"https://www.dagbladet.no/kjendis/avviser-vennskap/81332289\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Avviser vennskap\" alt=\"Image: Avviser vennskap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81332380&amp;panoy=3.030303030303&amp;panow=99.842766981132&amp;panoh=44.040403636364&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Avviser</span><span class=\"x__pt8tzk-0 ldTjgH title dynamic-sizing\">vennskap</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Reagerer: - Rapporter det\" href=\"https://www.dagbladet.no/kjendis/reagerer-rapporter-det/81342902\"><figure class=\"x__sc-1an7vu1-0 jjcUMQ\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Rapporter det\" alt=\"Image: Reagerer: - Rapporter det\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342917&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panoy=4.2553191489362&amp;heightw=41.106128251121&amp;heighty=0.22371409395974&amp;heightx=56.95067264574&amp;heighth=99.77628590604&amp;width=485&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfcAvK title dynamic-sizing\">Reagerer:</span><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">- Rapporter det</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ordkrigen fortsetter\" href=\"https://www.dagbladet.no/sport/ordkrigen-fortsetter/81341319\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ordkrigen fortsetter\" alt=\"Image: Ordkrigen fortsetter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341377&amp;panow=42.166344294004&amp;panoh=21.700879765396&amp;panoy=6.4516129032258&amp;panox=28.239845261122&amp;heightx=40&amp;heightw=18.989898989899&amp;heighth=46.223564954683&amp;heighty=6.0422960725076&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hjGKKq title dynamic-sizing\">Ordkrigen</span><span class=\"x__pt8tzk-0 ctWqNs title dynamic-sizing\">fortsetter</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard5\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dukket opp naken på jobb\" href=\"https://www.dagbladet.no/video/dukket-opp-naken-pa-jobb/7M8Rspms\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Dukket opp naken på jobb\" alt=\"Image: Dukket opp naken på jobb\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/7M8Rspms-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Dukket opp</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">naken på jobb</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fellene: Banken spiser pensjonen\" href=\"https://www.dagbladet.no/tema/fellene-banken-spiser-pensjonen/81173450\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Fellene: Banken spiser pensjonen\" alt=\"Image: Fellene: Banken spiser pensjonen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81153720&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Fellene: Banken</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">spiser pensjonen</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Overtalte mannen: - Lever bare en gang\" href=\"https://www.dagbladet.no/kjendis/overtalte-mannen-lever-bare-en-gang/81339840\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Overtalte mannen: - Lever bare en gang\" alt=\"Image: Overtalte mannen: - Lever bare en gang\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81337789&amp;panox=16.387959866221&amp;panoy=11.557788944724&amp;panow=70.234113712375&amp;panoh=35.678391959799&amp;heightx=30.196078431373&amp;heightw=35.294117647059&amp;heighth=85.964912280702&amp;heighty=5.8479532163743&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eYoKgk title dynamic-sizing\">Overtalte mannen:</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">- Lever bare en gang</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bekrefter: Flere kollapset\" href=\"https://www.dagbladet.no/sport/bekrefter-flere-kollapset/81340751\"><figure class=\"x__sc-1an7vu1-0 dwEuyS\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter: Flere kollapset\" alt=\"Image: Bekrefter: Flere kollapset\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81340754&amp;panoy=17.721518987342&amp;panox=0&amp;panow=100&amp;panoh=44.936708860759&amp;heightw=45.918367346939&amp;heighth=100&amp;heighty=0&amp;heightx=20.408163265306&amp;width=402&amp;height=263&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">Bekrefter:</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">Flere kollapset</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sommerværet fortsetter: Varsler 25 grader\" href=\"https://www.dagbladet.no/nyheter/sommervaeret-fortsetter-varsler-25-grader/81342225\"><figure class=\"x__sc-1an7vu1-0 jbNkVD\"><picture><img data-defer=\"view\" title=\"Image: Sommerværet fortsetter: Varsler 25 grader\" alt=\"Image: Sommerværet fortsetter: Varsler 25 grader\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342741&amp;panoy=58.235294117647&amp;panox=0&amp;panow=100&amp;panoh=41.764705882353&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=482&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Sommerværet fortsetter:</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">Varsler 25 grader</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"«Jakten»-par skilles\" href=\"https://www.dagbladet.no/kjendis/jakten-par-skilles/81340586\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: «Jakten»-par skilles\" alt=\"Image: «Jakten»-par skilles\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81340648&amp;panox=18.2156133829&amp;panoy=3.9325842696629&amp;panow=78.686492936803&amp;panoh=40.823969662921&amp;heightw=41.106128251121&amp;heighty=0&amp;heightx=34.529147982063&amp;heighth=99.77628590604&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 SXEmE title dynamic-sizing\">«Jakten»-par</span><span class=\"x__pt8tzk-0 fqIxnw title dynamic-sizing\">skilles</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=\"Sjøgrens: Ta disse tegnene på alvor\" href=\"https://www.dagbladet.no/tema/sjogrens-ta-disse-tegnene-pa-alvor/81333224\"><figure class=\"x__sc-1an7vu1-0 kkbWxc\"><picture><img data-defer=\"view\" title=\"Image: Sjøgrens: Ta disse tegnene på alvor\" alt=\"Image: Sjøgrens: Ta disse tegnene på alvor\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342634&amp;panoy=20.567375886525&amp;panox=0&amp;panow=100&amp;panoh=49.645390070922&amp;heightw=42.105263157895&amp;heighth=100&amp;heightx=30.143540669856&amp;heighty=0&amp;width=320&amp;height=311&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Sjøgrens: Ta disse</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">tegnene på alvor</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russisk gassrørledning ødelagt\" href=\"https://www.dagbladet.no/video/russisk-gassrorledning-odelagt/oVX5OQgJ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russisk gassrørledning ødelagt\" alt=\"Image: Russisk gassrørledning ødelagt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/oVX5OQgJ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iyrywY title dynamic-sizing\">Russisk</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">gassrørledning</span><span class=\"x__pt8tzk-0 bFQuDG title dynamic-sizing\">ødelagt</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=\"Tar nettet med storm\" href=\"https://www.dagbladet.no/annonse/disse-produktene-skal-alle-ha-na/81279229?allerID=1202404181\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fdycFS\"><picture><img data-defer=\"view\" title=\"Image: Tar nettet med storm\" alt=\"Image: Tar nettet med storm\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/81344479.jpg?imageId=81344479&amp;x=3.364486&amp;y=13.580247&amp;cropw=91.588785&amp;croph=77.777778&amp;width=320&amp;height=200&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 LzBnW title dynamic-sizing\">Tar nettet</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">med storm</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skjerper reiseråd for Malmö\" href=\"https://www.dagbladet.no/nyheter/skjerper-reiserad-for-malmo/81345129\"><figure class=\"x__sc-1an7vu1-0 ifbRza\"><picture><img data-defer=\"view\" title=\"Image: Skjerper reiseråd for Malmö\" alt=\"Image: Skjerper reiseråd for Malmö\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81345144&amp;panow=100&amp;panoy=0&amp;panoh=50.714285714286&amp;panox=0&amp;heighty=0&amp;heightx=30.316742081448&amp;heightw=40.723981900452&amp;heighth=100&amp;width=402&amp;height=348&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Skjerper reiseråd</span><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">for Malmö</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Bør stille oss spørsmålet \" href=\"https://www.dagbladet.no/nyheter/bor-stille-oss-sporsmalet/81344170\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Bør stille oss spørsmålet \" alt=\"Image: - Bør stille oss spørsmålet \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81344230&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kLBvft title dynamic-sizing\">- Bør stille</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">oss spørsmålet </span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kan vi bare gi henne en sjanse?\" href=\"https://www.dagbladet.no/kjendis/kan-vi-bare-gi-henne-en-sjanse/81343543\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Kan vi bare gi henne en sjanse?\" alt=\"Image: - Kan vi bare gi henne en sjanse?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343430&amp;panow=100&amp;panoh=22.977346278317&amp;panoy=9.7087378640777&amp;panox=0&amp;heighth=52.127659574468&amp;heightw=47.120418848168&amp;heighty=3.1914893617021&amp;heightx=28.795811518325&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">- Kan vi bare gi</span><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">henne en sjanse?</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Nå sliter jeg\" href=\"https://www.dagbladet.no/kjendis/na-sliter-jeg/81343311\"><figure class=\"x__sc-1an7vu1-0 fUGaTG\"><picture><img data-defer=\"view\" title=\"Image: - Nå sliter jeg\" alt=\"Image: - Nå sliter jeg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343315&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=372&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">- Nå sliter jeg</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-smartbanner2\" class=\"adunit-wrapper columns small-12 medium-12 large-12 track-element  \" data-from=\"xavier\"><div id=\"ad-smartbanner2\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600],[980,300],[970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;smartbanner2&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Påvist i Norge\" href=\"https://www.dagbladet.no/nyheter/pavist-i-norge/81337338\"><figure class=\"x__sc-1an7vu1-0 dkrHKM\"><picture><img data-defer=\"view\" title=\"Image: Påvist i Norge\" alt=\"Image: Påvist i Norge\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81337346&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightw=34.351145038168&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=261&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">Påvist i Norge</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Etterlysning forskrekker: - Verste jeg har sett\" href=\"https://www.dagbladet.no/nyheter/etterlysning-forskrekker-verste-jeg-har-sett/81338335\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Etterlysning forskrekker: - Verste jeg har sett\" alt=\"Image: Etterlysning forskrekker: - Verste jeg har sett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338360&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=34.027778846154&amp;panoy=31.25&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">Etterlysning forskrekker:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">- Verste jeg har sett</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Det er ulovlig\" href=\"https://www.dagbladet.no/nyheter/det-er-ulovlig/81346215\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Det er ulovlig\" alt=\"Image: - Det er ulovlig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81346262&amp;panoh=50.714285714286&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=201&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bvsVFh title dynamic-sizing\">- Det er</span><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">ulovlig</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ellevill prislapp: - Jeg lærer aldri\" href=\"https://www.dagbladet.no/kjendis/ellevill-prislapp-jeg-laerer-aldri/81339665\"><figure class=\"x__sc-1an7vu1-0 jBjOhG\"><picture><img data-defer=\"view\" title=\"Image: Ellevill prislapp: - Jeg lærer aldri\" alt=\"Image: Ellevill prislapp: - Jeg lærer aldri\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339757&amp;panoh=51.449275362319&amp;panoy=8.695652173913&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=293&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">Ellevill prislapp:</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">- Jeg lærer aldri</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Innrømmer «juks» i NRK-program\" href=\"https://www.dagbladet.no/video/innrommer-juks-i-nrk-program/lMkzrfpg\"><figure class=\"x__sc-1an7vu1-0 eIlDNY\"><picture><img data-defer=\"view\" title=\"Image: Innrømmer «juks» i NRK-program\" alt=\"Image: Innrømmer «juks» i NRK-program\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/lMkzrfpg-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Innrømmer «juks»</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">i NRK-program</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer mot matvarer: Gir uren hud \" href=\"https://www.dagbladet.no/tema/advarer-mot-matvarer-gir-uren-hud/81273523\"><figure class=\"x__sc-1an7vu1-0 eIlDNY\"><picture><img data-defer=\"view\" title=\"Image: Advarer mot matvarer: Gir uren hud \" alt=\"Image: Advarer mot matvarer: Gir uren hud \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342684&amp;panox=0&amp;panow=100&amp;panoh=51.094890510949&amp;panoy=14.598540145985&amp;heighth=100&amp;heighty=0&amp;heightx=46.976744186047&amp;heightw=40.93023255814&amp;width=320&amp;height=165&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">Advarer mot matvarer:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Gir uren hud </span></h3></header></a></article><div id=\"apos-medium-rectangle4\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle4\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Jeg tjente mer penger enn ham\" href=\"https://www.dagbladet.no/kjendis/jeg-tjente-mer-penger-enn-ham/81309172\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Jeg tjente mer penger enn ham\" alt=\"Image: - Jeg tjente mer penger enn ham\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335652&amp;panoy=15.969581749049&amp;panox=0&amp;panow=100&amp;panoh=26.996197718631&amp;heightx=19.178082191781&amp;heightw=61.643835616438&amp;heighth=81.21546961326&amp;heighty=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">- Jeg tjente mer</span><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">penger enn ham</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Hun får null\" href=\"https://www.dagbladet.no/kjendis/hun-far-null/81338869\"><figure class=\"x__sc-1an7vu1-0 jVuBDT\"><picture><img data-defer=\"view\" title=\"Image: Hun får null\" alt=\"Image: Hun får null\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81114425&amp;panoy=20.287769784173&amp;panox=27.291666666667&amp;panow=43.75&amp;panoh=10.215827338129&amp;heightx=30.125523012552&amp;heightw=37.65690376569&amp;heighth=42.363112391931&amp;heighty=19.020172910663&amp;width=485&amp;height=282&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">Hun får null</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Nå eller aldri\" href=\"https://www.dagbladet.no/nyheter/na-eller-aldri/81341899\"><figure class=\"x__sc-1an7vu1-0 kMOLOX\"><picture><img data-defer=\"view\" title=\"Image: - Nå eller aldri\" alt=\"Image: - Nå eller aldri\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341904&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=485&amp;height=384&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">- Nå eller aldri</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ikke en krone for mye\" href=\"https://www.dagbladet.no/meninger/ikke-en-krone-for-mye/81339112\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ikke en krone for mye\" alt=\"Image: Ikke en krone for mye\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81336008&amp;panow=100.19047619048&amp;panoh=51.714285714286&amp;panoy=15.714285714286&amp;panox=0.19047619047619&amp;heightx=28.054298642534&amp;heighty=0.27210884353742&amp;heightw=40.904977375566&amp;heighth=100.27210884354&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Ikke en</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">krone for mye</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard6\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Chipsen som slanker\" href=\"https://www.dagbladet.no/tema/chipsen-som-slanker/81172275\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Chipsen som slanker\" alt=\"Image: Chipsen som slanker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81172832&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jFsmoq title dynamic-sizing\">Chipsen</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">som slanker</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russerne stjeler svensk våpen - angrer\" href=\"https://www.dagbladet.no/video/russerne-stjeler-svensk-vapen-angrer/GBzaqmRd\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russerne stjeler svensk våpen - angrer\" alt=\"Image: Russerne stjeler svensk våpen - angrer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/GBzaqmRd-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Russerne stjeler</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">svensk våpen - angrer</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dødsfelle: Tar grep\" href=\"https://www.dagbladet.no/nyheter/dodsfelle-tar-grep/81334163\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dødsfelle: Tar grep\" alt=\"Image: Dødsfelle: Tar grep\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81335353&amp;panow=100&amp;panoy=10.666666666667&amp;panox=0&amp;panoh=47.333333333333&amp;heightx=38.834951456311&amp;heightw=43.68932038835&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iKalhP title dynamic-sizing\">Dødsfelle:</span><span class=\"x__pt8tzk-0 iWZcdV title dynamic-sizing\">Tar grep</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ugjenkjennelig\" href=\"https://www.dagbladet.no/kjendis/ugjenkjennelig/81341651\"><figure class=\"x__sc-1an7vu1-0 dsoRmW\"><picture><img data-defer=\"view\" title=\"Image: Ugjenkjennelig\" alt=\"Image: Ugjenkjennelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341702&amp;panoh=22.851152830189&amp;panoy=6.2893081761006&amp;panox=0&amp;panow=99.842766981132&amp;heightw=92.592591919192&amp;heighty=0&amp;heightx=0&amp;heighth=99.77628590604&amp;width=402&amp;height=484&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 lfBuL title dynamic-sizing\">Ugjenkjennelig</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Møtt av skrekksyn: - Ikke høysesong\" href=\"https://www.dagbladet.no/nyheter/mott-av-skrekksyn-ikke-hoysesong/81342657\"><figure class=\"x__sc-1an7vu1-0 UytSm\"><picture><img data-defer=\"view\" title=\"Image: Møtt av skrekksyn: - Ikke høysesong\" alt=\"Image: Møtt av skrekksyn: - Ikke høysesong\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343036&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=328&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Møtt av skrekksyn:</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">- Ikke høysesong</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"USA: Brøt forbud mot kjemiske våpen\" href=\"https://www.dagbladet.no/nyheter/usa-brot-forbud-mot-kjemiske-vapen/81341223\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: USA: Brøt forbud mot kjemiske våpen\" alt=\"Image: USA: Brøt forbud mot kjemiske våpen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341229&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cGLrSG title dynamic-sizing\">USA: Brøt forbud</span><span class=\"x__pt8tzk-0 bvXqXn title dynamic-sizing\">mot kjemiske våpen</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kuttet to ting: Kim ned 20 kilo\" href=\"https://www.dagbladet.no/tema/kuttet-to-ting-kim-ned-20-kilo/81333973\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Kuttet to ting: Kim ned 20 kilo\" alt=\"Image: Kuttet to ting: Kim ned 20 kilo\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=79792392&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=49.54128440367&amp;heightw=13.608562691131&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Kuttet to ting:</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Kim ned 20 kilo</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Latterliggjør feil president: - En tosk\" href=\"https://www.dagbladet.no/video/latterliggjor-feil-president-en-tosk/dt6pVyx3\"><figure class=\"x__sc-1an7vu1-0 gYoHKl\"><picture><img data-defer=\"view\" title=\"Image: Latterliggjør feil president: - En tosk\" alt=\"Image: Latterliggjør feil president: - En tosk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/dt6pVyx3-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Latterliggjør feil</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">president: - En tosk</span></h3></header></a></article><div id=\"apos-medium-rectangle5\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle5\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Åpner for å overvåke gravide\" href=\"https://www.dagbladet.no/nyheter/apner-for-a-overvake-gravide/81338186\"><figure class=\"x__sc-1an7vu1-0 eWEEkc\"><picture><img data-defer=\"view\" title=\"Image: Åpner for å overvåke gravide\" alt=\"Image: Åpner for å overvåke gravide\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338195&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=249&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 XaoDC title dynamic-sizing\">Åpner for å</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">overvåke gravide</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Barna dine skal se dette\" href=\"https://www.dagbladet.no/kjendis/barna-dine-skal-se-dette/81337738\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Barna dine skal se dette\" alt=\"Image: - Barna dine skal se dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338029&amp;panow=100&amp;panoh=26.996197718631&amp;panoy=46.768060836502&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">- Barna dine</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">skal se dette</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bekrefter Gjerts taushet\" href=\"https://www.dagbladet.no/sport/bekrefter-gjerts-taushet/81339460\"><figure class=\"x__sc-1an7vu1-0 iBoTJJ\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter Gjerts taushet\" alt=\"Image: Bekrefter Gjerts taushet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339785&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=304&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">Bekrefter</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Gjerts taushet</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Meldingen rystet: - Overrasket\" href=\"https://www.dagbladet.no/sport/meldingen-rystet-overrasket/81338167\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Meldingen rystet: - Overrasket\" alt=\"Image: Meldingen rystet: - Overrasket\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338171&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iLHueX title dynamic-sizing\">Meldingen rystet:</span><span class=\"x__pt8tzk-0 iQrIZq title dynamic-sizing\">- Overrasket</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard7\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russisk missil-skandale i Østersjøen\" href=\"https://www.dagbladet.no/video/russisk-missil-skandale-i-ostersjoen/fJ0HGbqF\"><figure class=\"x__sc-1an7vu1-0 gmpxUf\"><picture><img data-defer=\"view\" title=\"Image: Russisk missil-skandale i Østersjøen\" alt=\"Image: Russisk missil-skandale i Østersjøen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/fJ0HGbqF-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Russisk missil-skandale</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">i Østersjøen</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=\"Skattetipset eldre glemmer: - Betydelige summer\" href=\"https://www.dagbladet.no/tema/skattetipset-eldre-glemmer-betydelige-summer/81287267\"><figure class=\"x__sc-1an7vu1-0 gmpxUf\"><picture><img data-defer=\"view\" title=\"Image: Skattetipset eldre glemmer: - Betydelige summer\" alt=\"Image: Skattetipset eldre glemmer: - Betydelige summer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81287629&amp;panoy=14.893617021277&amp;panox=0.15723301886793&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;heighty=0.22371409395974&amp;heightx=32.735426008969&amp;width=320&amp;height=178&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bUEFlv title dynamic-sizing\">Skattetipset eldre glemmer:</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">- Betydelige summer</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nektet å forlate ektemannen\" href=\"https://www.dagbladet.no/nyheter/nektet-a-forlate-ektemannen/81338366\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Nektet å forlate ektemannen\" alt=\"Image: Nektet å forlate ektemannen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338673&amp;panoy=31.178707224335&amp;panow=100&amp;panoh=26.996197718631&amp;panox=0&amp;heighty=12.254901960784&amp;heightx=32.121212121212&amp;heightw=54.545454545455&amp;heighth=72.058823529412&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">Nektet å forlate</span><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">ektemannen</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Politiet vil heve mystisk fryseboks\" href=\"https://www.dagbladet.no/nyheter/politiet-vil-heve-mystisk-fryseboks/81343137\"><figure class=\"x__sc-1an7vu1-0 beBWtS\"><picture><img data-defer=\"view\" title=\"Image: Politiet vil heve mystisk fryseboks\" alt=\"Image: Politiet vil heve mystisk fryseboks\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81343159&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=270&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">Politiet vil heve</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">mystisk fryseboks</span></h3></header></a></article></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=\"AFP-fella: 1,3 mill mindre\" href=\"https://www.dagbladet.no/tema/afp-fella-13-mill-mindre/81275737\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: AFP-fella: 1,3 mill mindre\" alt=\"Image: AFP-fella: 1,3 mill mindre\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81285839&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">AFP-fella: 1,3</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">mill mindre</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Absurde bilder fra slagmarken\" href=\"https://www.dagbladet.no/video/absurde-bilder-fra-slagmarken/tnjArkKd\"><figure class=\"x__sc-1an7vu1-0 gYoHKl\"><picture><img data-defer=\"view\" title=\"Image: Absurde bilder fra slagmarken\" alt=\"Image: Absurde bilder fra slagmarken\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/tnjArkKd-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eVBoHG title dynamic-sizing\">Absurde bilder</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">fra slagmarken</span></h3></header></a></article><div id=\"apos-medium-rectangle6\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle6\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gikk helt galt: - Var splitter ny!\" href=\"https://www.dagbladet.no/nyheter/gikk-helt-galt-var-splitter-ny/81339280\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Gikk helt galt: - Var splitter ny!\" alt=\"Image: Gikk helt galt: - Var splitter ny!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339290&amp;panoy=29.136690647482&amp;panox=0.10632535885167&amp;panow=99.893674641148&amp;panoh=25.459633093525&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">Gikk helt galt:</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">- Var splitter ny!</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fikk panikk: - Så ufattelig skuffet\" href=\"https://www.dagbladet.no/kjendis/fikk-panikk-sa-ufattelig-skuffet/81336401\"><figure class=\"x__sc-1an7vu1-0 jFHrOt\"><picture><img data-defer=\"view\" title=\"Image: Fikk panikk: - Så ufattelig skuffet\" alt=\"Image: Fikk panikk: - Så ufattelig skuffet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81337489&amp;panoy=13.880126182965&amp;panox=0&amp;panow=99.842766981132&amp;panoh=22.851152830189&amp;heightw=92.592591919192&amp;heighth=99.77628590604&amp;heighty=0.22371409395974&amp;heightx=7.4074080808081&amp;width=402&amp;height=342&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Fikk panikk: - Så</span><span class=\"x__pt8tzk-0 wpWLG title dynamic-sizing\">ufattelig skuffet</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard8\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"– Seks av syv spenn ødelagt\" href=\"https://www.dagbladet.no/video/-seks-av-syv-spenn-odelagt/nBm27GIO\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: – Seks av syv spenn ødelagt\" alt=\"Image: – Seks av syv spenn ødelagt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/nBm27GIO-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">– Seks av syv</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">spenn ødelagt</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Synsvansker røpet alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/synsvansker-ropet-alvorlig-sykdom/81279388\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Synsvansker røpet alvorlig sykdom\" alt=\"Image: Synsvansker røpet alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81288776&amp;panow=100&amp;panoh=100&amp;panox=0&amp;panoy=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Synsvansker røpet</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">alvorlig sykdom</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Quiz uke 18: Simens ti kjappe!\" href=\"https://www.dagbladet.no/sport/quiz-uke-18-simens-ti-kjappe/81343884\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Quiz uke 18: Simens ti kjappe!\" alt=\"Image: Quiz uke 18: Simens ti kjappe!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81056783&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Quiz uke 18:</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Simens ti kjappe!</span></h3></header></a></article><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=\"Frida Karlsson vekker oppsikt i Norge\" href=\"https://www.dagbladet.no/video/frida-karlsson-vekker-oppsikt-i-norge/iiSU9EIo\"><figure class=\"x__sc-1an7vu1-0 gYoHKl\"><picture><img data-defer=\"view\" title=\"Image: Frida Karlsson vekker oppsikt i Norge\" alt=\"Image: Frida Karlsson vekker oppsikt i Norge\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/iiSU9EIo-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dPoeFo title dynamic-sizing\">Frida Karlsson vekker</span><span class=\"x__pt8tzk-0 cZmotM title dynamic-sizing\">oppsikt i Norge</span></h3></header></a></article><div id=\"apos-medium-rectangle7\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle7\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Rammet av kreft\" href=\"https://www.dagbladet.no/sport/rammet-av-kreft/81338531\"><figure class=\"x__sc-1an7vu1-0 jBzAwk\"><picture><img data-defer=\"view\" title=\"Image: Rammet av kreft\" alt=\"Image: Rammet av kreft\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338589&amp;panoy=2.928870292887&amp;panox=0&amp;panow=100&amp;panoh=30.125523012552&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=272&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Rammet av kreft</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Heia Brann\" href=\"https://www.dagbladet.no/meninger/heia-brann/81342924\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Heia Brann\" alt=\"Image: Heia Brann\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80565328&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=242&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kpDSmG title dynamic-sizing\">Heia Brann</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Torturerte terroristene: - Et større problem\" href=\"https://www.dagbladet.no/video/torturerte-terroristene-et-storre-problem/2OjzIlTb\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Torturerte terroristene: - Et større problem\" alt=\"Image: Torturerte terroristene: - Et større problem\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/2OjzIlTb-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Torturerte terroristene:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">- Et større problem</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=\"Lille August kan dø\" href=\"https://www.dagbladet.no/tema/lille-august-kan-do/81329028\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Lille August kan dø\" alt=\"Image: Lille August kan dø\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81310932&amp;panow=70.382883108108&amp;panoh=24.099099324324&amp;panoy=13.513513513514&amp;panox=2.3648648648649&amp;heighty=9.3023255813953&amp;heightx=15.813953488372&amp;heightw=41.550387906977&amp;heighth=68.062015813953&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 zWscE title dynamic-sizing\">Lille August kan dø</span></h3></header></a></article></div></div><div id=\"apos-netboard9\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard9\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Klarte ikke EM-kravet\" href=\"https://www.dagbladet.no/sport/klarte-ikke-em-kravet/81339728\"><figure class=\"x__sc-1an7vu1-0 dGSQcf\"><picture><img data-defer=\"view\" title=\"Image: Klarte ikke EM-kravet\" alt=\"Image: Klarte ikke EM-kravet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81339904&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightw=100&amp;heightx=0&amp;heighth=100&amp;width=402&amp;height=288&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jPbWVE title dynamic-sizing\">Klarte ikke</span><span class=\"x__pt8tzk-0 gWsWwS title dynamic-sizing\">EM-kravet</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gutt (7) hentet opp av vannet\" href=\"https://www.dagbladet.no/nyheter/gutt-7-hentet-opp-av-vannet/81341698\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Gutt (7) hentet opp av vannet\" alt=\"Image: Gutt (7) hentet opp av vannet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81341743&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">Gutt (7) hentet</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">opp av vannet</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=\"Helene ned 30 kilo: Oppsiktsvekkende metode\" href=\"https://www.dagbladet.no/tema/helene-ned-30-kilo-oppsiktsvekkende-metode/81287177\"><figure class=\"x__sc-1an7vu1-0 kHDOtO\"><picture><img data-defer=\"view\" title=\"Image: Helene ned 30 kilo: Oppsiktsvekkende metode\" alt=\"Image: Helene ned 30 kilo: Oppsiktsvekkende metode\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81287397&amp;panoy=0.31298591549295&amp;panox=0&amp;panow=98.017737089202&amp;panoh=99.687014084507&amp;heightx=38.584474885845&amp;heightw=20.497210045662&amp;heighth=99.847794520548&amp;heighty=0&amp;width=320&amp;height=252&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Helene ned 30 kilo:</span><span class=\"x__pt8tzk-0 jRIgeY title dynamic-sizing\">Oppsiktsvekkende metode</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Turistene får sjokk\" href=\"https://www.dagbladet.no/video/turistene-far-sjokk/l9wjU8LV\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Turistene får sjokk\" alt=\"Image: Turistene får sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/l9wjU8LV-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">Turistene</span><span class=\"x__pt8tzk-0 kCKswK title dynamic-sizing\">får sjokk</span></h3></header></a></article><div id=\"apos-medium-rectangle8\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dommersjef vil ha VAR-endring\" href=\"https://www.dagbladet.no/sport/dommersjef-vil-ha-var-endring/81342382\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dommersjef vil ha VAR-endring\" alt=\"Image: Dommersjef vil ha VAR-endring\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81342393&amp;panoy=16.428571428571&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;heightx=28.9592760181&amp;width=567&amp;height=283&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwzwBX title dynamic-sizing\">Dommersjef vil</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">ha VAR-endring</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Har inntatt ferieparadis\" href=\"https://www.dagbladet.no/nyheter/har-inntatt-ferieparadis/81337567\"><figure class=\"x__sc-1an7vu1-0 evkaIe\"><picture><img data-defer=\"view\" title=\"Image: Har inntatt ferieparadis\" alt=\"Image: Har inntatt ferieparadis\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81338005&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=284&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">Har inntatt</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">ferieparadis</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard10\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard10\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Legger opp etter dette\" href=\"https://www.dagbladet.no/video/legger-opp-etter-dette/1iH4rxuP\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Legger opp etter dette\" alt=\"Image: Legger opp etter dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/1iH4rxuP-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Legger opp</span><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">etter dette</span></h3></header></a></article><article class=\"preview columns small-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=\"Uskiftet bo-felle: Barna får ingenting \" href=\"https://www.dagbladet.no/tema/uskiftet-bo-felle-barna-far-ingenting/81124173\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Uskiftet bo-felle: Barna får ingenting \" alt=\"Image: Uskiftet bo-felle: Barna får ingenting \" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81230110&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Uskiftet bo-felle:</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Barna får ingenting </span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Supergrepet: Annette (52) raste ned i vekt\" href=\"https://www.dagbladet.no/tema/supergrepet-annette-52-raste-ned-i-vekt/81173683\"><figure class=\"x__sc-1an7vu1-0 fpylwJ\"><picture><img data-defer=\"view\" title=\"Image: Supergrepet: Annette (52) raste ned i vekt\" alt=\"Image: Supergrepet: Annette (52) raste ned i vekt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81183655&amp;panoy=0&amp;panow=97.757847533632&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=40.217391304348&amp;heightw=20.434782608696&amp;heighth=100&amp;width=320&amp;height=284&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Supergrepet: Annette</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">(52) raste ned i vekt</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Frankrike: - Oppfattet som trussel\" href=\"https://www.dagbladet.no/video/frankrike-oppfattet-som-trussel/kxbj70aR\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Frankrike: - Oppfattet som trussel\" alt=\"Image: Frankrike: - Oppfattet som trussel\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/kxbj70aR-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 glOqqI title dynamic-sizing\">Frankrike:</span><span class=\"x__pt8tzk-0 jIyTDK title dynamic-sizing\">- Oppfattet</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">som trussel</span></h3></header></a></article><div id=\"apos-medium-rectangle9\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard11\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Livsfarlig\" href=\"https://www.dagbladet.no/video/-livsfarlig/FWV0OCuM\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: - Livsfarlig\" alt=\"Image: - Livsfarlig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/FWV0OCuM-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jIyTDK title dynamic-sizing\">- Livsfarlig</span></h3></header></a></article><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=\"Frasene som skader barna\" href=\"https://www.dagbladet.no/tema/frasene-som-skader-barna/81107931\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Frasene som skader barna\" alt=\"Image: Frasene som skader barna\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81124396&amp;panow=74.48275862069&amp;panoh=37.823834196891&amp;panoy=22.79792746114&amp;panox=25.51724137931&amp;heighty=0&amp;heightx=49.557522123894&amp;heightw=40.70796460177&amp;heighth=100&amp;width=320&amp;height=164&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Frasene som</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">skader barna</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"21 menn: Derfor er vi utro\" href=\"https://www.dagbladet.no/tema/21-menn-derfor-er-vi-utro/81127951\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: 21 menn: Derfor er vi utro\" alt=\"Image: 21 menn: Derfor er vi utro\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81138572&amp;panoy=14.193548387097&amp;panox=5.5555555555556&amp;panow=88.675213675214&amp;panoh=45.483870967742&amp;heighty=0.3448275862069&amp;heightw=40.596330275229&amp;heighth=100.34482758621&amp;heightx=21.559633027523&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">21 menn: Derfor</span><span class=\"x__pt8tzk-0 bHxiDg title dynamic-sizing\">er vi utro</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Larvik: - Politiet var oppgitt\" href=\"https://www.dagbladet.no/video/larvik-politiet-var-oppgitt/WWtMk2hx\"><figure class=\"x__sc-1an7vu1-0 iRrFGC\"><picture><img data-defer=\"view\" title=\"Image: Larvik: - Politiet var oppgitt\" alt=\"Image: Larvik: - Politiet var oppgitt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/WWtMk2hx-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ihkPAv title dynamic-sizing\">Larvik: - Politiet</span><span class=\"x__pt8tzk-0 jIyTDK title dynamic-sizing\">var oppgitt</span></h3></header></a></article><div id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Den farligste - og minst farlige snusen\" href=\"https://www.dagbladet.no/tema/den-farligste-og-minst-farlige-snusen/81206403\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Den farligste - og minst farlige snusen\" alt=\"Image: Den farligste - og minst farlige snusen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81212270&amp;panox=0&amp;panow=99.759615384615&amp;panoh=59.745762711864&amp;panoy=11.864406779661&amp;heightx=31.764705882353&amp;heighty=0.3448275862069&amp;heightw=34.705882352941&amp;heighth=100.34482758621&amp;width=320&amp;height=160&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">Den farligste - og</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">minst farlige snusen</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12 bg-black\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Oslo: Skutt på åpen gate\" href=\"https://www.dagbladet.no/video/oslo-skutt-pa-apen-gate/BSIUH2PN\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Oslo: Skutt på åpen gate\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/81295555.jpg?imageId=81295555&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2024/04/21/60ab2cff-ad21-4051-8db1-58207e579204/gif_1_klingenberg.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2024/04/21/60ab2cff-ad21-4051-8db1-58207e579204/gif_1_klingenberg.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">Oslo: Skutt</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">på åpen gate</span></h3></header></a></article></div></div><div id=\"apos-netboard12\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard12&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Seks populære elsykler: - Velg denne!\" href=\"https://www.dagbladet.no/tema/seks-populaere-elsykler-velg-denne/81090828\"><figure class=\"x__sc-1an7vu1-0 gkSegO\"><picture><img data-defer=\"view\" title=\"Image: Seks populære elsykler: - Velg denne!\" alt=\"Image: Seks populære elsykler: - Velg denne!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=81286379&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=211&amp;compression=70\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Seks populære</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">elsykler: - Velg denne!</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Her avskjæres russerne\" href=\"https://www.dagbladet.no/video/her-avskjaeres-russerne/uH793H8Q\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Her avskjæres russerne\" alt=\"Image: Her avskjæres russerne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uH793H8Q-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\" loading=\"lazy\" fetchPriority=\"auto\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Her avskjæres</span><span class=\"x__pt8tzk-0 kCKswK title dynamic-sizing\">russerne</span></h3></header></a></article><div id=\"apos-medium-rectangle11\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle11\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div>"]