Vil holde Stortinget utenfor
Full krig i hytteparadis:
Sjøperle tvangsselges: Eieren raser
Avslører overraskende hobby
Her endte corona-millionene
0
Trosser forbudet- raser!
0
Ida (36) merket ingenting- hadde livmorhalskreft
Annonsørinnhold
Nye fargekombinasjonertil terrassen
i samarbeid med
0
- Tror ikkejeg imponerer
0
Lars’ (53) oppgjørmed alkoholen
Annonsørinnhold
Nyhet: Superpopulærtkosttilskudd for hund
i samarbeid med
["<style data-styled=\"true\" data-styled-version=\"5.2.1\">.exnSmk.exnSmk.exnSmk.exnSmk{height:0;padding-bottom:50%;}/*!sc*/ .beQEWY.beQEWY.beQEWY.beQEWY{height:0;padding-bottom:52.37%;}/*!sc*/ .YaeJb.YaeJb.YaeJb.YaeJb{height:0;padding-bottom:49.89%;}/*!sc*/ .jhCdqv.jhCdqv.jhCdqv.jhCdqv{height:0;padding-bottom:50.1%;}/*!sc*/ .gqRXqT.gqRXqT.gqRXqT.gqRXqT{height:0;padding-bottom:72.81%;}/*!sc*/ .eXdDG.eXdDG.eXdDG.eXdDG{height:0;padding-bottom:49.91%;}/*!sc*/ .cKiVil.cKiVil.cKiVil.cKiVil{height:0;padding-bottom:94.52%;}/*!sc*/ .kdXjqn.kdXjqn.kdXjqn.kdXjqn{height:0;padding-bottom:91.04%;}/*!sc*/ .iUvBjr.iUvBjr.iUvBjr.iUvBjr{height:0;padding-bottom:61.03%;}/*!sc*/ .jmOGNB.jmOGNB.jmOGNB.jmOGNB{height:0;padding-bottom:103.73%;}/*!sc*/ .fwhPIB.fwhPIB.fwhPIB.fwhPIB{height:0;padding-bottom:59.68%;}/*!sc*/ .hYmQsU.hYmQsU.hYmQsU.hYmQsU{height:0;padding-bottom:63.75%;}/*!sc*/ .icWpRL.icWpRL.icWpRL.icWpRL{height:0;padding-bottom:52.16%;}/*!sc*/ .MGCdC.MGCdC.MGCdC.MGCdC{height:0;padding-bottom:56.28%;}/*!sc*/ .hzTaYt.hzTaYt.hzTaYt.hzTaYt{height:0;padding-bottom:62.68%;}/*!sc*/ .gOIElM.gOIElM.gOIElM.gOIElM{height:0;padding-bottom:88.3%;}/*!sc*/ .iefiXl.iefiXl.iefiXl.iefiXl{height:0;padding-bottom:52.81%;}/*!sc*/ .bIVEDS.bIVEDS.bIVEDS.bIVEDS{height:0;padding-bottom:50.62%;}/*!sc*/ .dFjCVh.dFjCVh.dFjCVh.dFjCVh{height:0;padding-bottom:65.67%;}/*!sc*/ .hGEcXL.hGEcXL.hGEcXL.hGEcXL{height:0;padding-bottom:94.27%;}/*!sc*/ .gBSNQe.gBSNQe.gBSNQe.gBSNQe{height:0;padding-bottom:54.84%;}/*!sc*/ .iOPyOl.iOPyOl.iOPyOl.iOPyOl{height:0;padding-bottom:119.65%;}/*!sc*/ .Xowsl.Xowsl.Xowsl.Xowsl{height:0;padding-bottom:88.75%;}/*!sc*/ .eenqZc.eenqZc.eenqZc.eenqZc{height:0;padding-bottom:64.94%;}/*!sc*/ .flPIvJ.flPIvJ.flPIvJ.flPIvJ{height:0;padding-bottom:50.3%;}/*!sc*/ .cFJCDt.cFJCDt.cFJCDt.cFJCDt{height:0;padding-bottom:60.44%;}/*!sc*/ .jiWEZa.jiWEZa.jiWEZa.jiWEZa{height:0;padding-bottom:68.65%;}/*!sc*/ .dcUdQe.dcUdQe.dcUdQe.dcUdQe{height:0;padding-bottom:62.81%;}/*!sc*/ .pQzcV.pQzcV.pQzcV.pQzcV{height:0;padding-bottom:101.24%;}/*!sc*/ .eRlIuJ.eRlIuJ.eRlIuJ.eRlIuJ{height:0;padding-bottom:58.96%;}/*!sc*/ .cOHzME.cOHzME.cOHzME.cOHzME{height:0;padding-bottom:57.5%;}/*!sc*/ .GhbEw.GhbEw.GhbEw.GhbEw{height:0;padding-bottom:73.38%;}/*!sc*/ .brVaep.brVaep.brVaep.brVaep{height:0;padding-bottom:55%;}/*!sc*/ .iSCaxr.iSCaxr.iSCaxr.iSCaxr{height:0;padding-bottom:76.49%;}/*!sc*/ .dquykX.dquykX.dquykX.dquykX{height:0;padding-bottom:79.35%;}/*!sc*/ .dSBzgi.dSBzgi.dSBzgi.dSBzgi{height:0;padding-bottom:53.43%;}/*!sc*/ .hJjTcc.hJjTcc.hJjTcc.hJjTcc{height:0;padding-bottom:69.15%;}/*!sc*/ .evVrtM.evVrtM.evVrtM.evVrtM{height:0;padding-bottom:66.56%;}/*!sc*/ .cqZIja.cqZIja.cqZIja.cqZIja{height:0;padding-bottom:53.12%;}/*!sc*/ .kIQEL.kIQEL.kIQEL.kIQEL{height:0;padding-bottom:60.93%;}/*!sc*/ .fjXeVU.fjXeVU.fjXeVU.fjXeVU{height:0;padding-bottom:69.37%;}/*!sc*/ data-styled.g108[id=\"sc-1an7vu1-0\"]{content:\"exnSmk,beQEWY,YaeJb,jhCdqv,gqRXqT,eXdDG,cKiVil,kdXjqn,iUvBjr,jmOGNB,fwhPIB,hYmQsU,icWpRL,MGCdC,hzTaYt,gOIElM,iefiXl,bIVEDS,dFjCVh,hGEcXL,gBSNQe,iOPyOl,Xowsl,eenqZc,flPIvJ,cFJCDt,jiWEZa,dcUdQe,pQzcV,eRlIuJ,cOHzME,GhbEw,brVaep,iSCaxr,dquykX,dSBzgi,hJjTcc,evVrtM,cqZIja,kIQEL,fjXeVU,\"}/*!sc*/ .htNVWC.htNVWC.htNVWC.htNVWC{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.htNVWC.htNVWC.htNVWC.htNVWC{font-size:1em!important;}}/*!sc*/ .fEoqYx.fEoqYx.fEoqYx.fEoqYx{font-size:2.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.fEoqYx.fEoqYx.fEoqYx.fEoqYx{font-size:0.7em!important;}}/*!sc*/ .mRkYR.mRkYR.mRkYR.mRkYR{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.mRkYR.mRkYR.mRkYR.mRkYR{font-size:1.6em!important;}}/*!sc*/ .kXXbDl.kXXbDl.kXXbDl.kXXbDl{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kXXbDl.kXXbDl.kXXbDl.kXXbDl{font-size:1.2em!important;}}/*!sc*/ .bvyTBk.bvyTBk.bvyTBk.bvyTBk{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvyTBk.bvyTBk.bvyTBk.bvyTBk{font-size:1.8em!important;}}/*!sc*/ .lokTIa.lokTIa.lokTIa.lokTIa{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.lokTIa.lokTIa.lokTIa.lokTIa{font-size:2.6em!important;}}/*!sc*/ .dRlPwV.dRlPwV.dRlPwV.dRlPwV{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dRlPwV.dRlPwV.dRlPwV.dRlPwV{font-size:1.4em!important;}}/*!sc*/ .fpIjBV.fpIjBV.fpIjBV.fpIjBV{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.fpIjBV.fpIjBV.fpIjBV.fpIjBV{font-size:1.2em!important;}}/*!sc*/ .fUMIho.fUMIho.fUMIho.fUMIho{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.fUMIho.fUMIho.fUMIho.fUMIho{font-size:2.5em!important;}}/*!sc*/ .jtRPEs.jtRPEs.jtRPEs.jtRPEs{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jtRPEs.jtRPEs.jtRPEs.jtRPEs{font-size:2.2em!important;}}/*!sc*/ .ckFdEF.ckFdEF.ckFdEF.ckFdEF{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.ckFdEF.ckFdEF.ckFdEF.ckFdEF{font-size:1.4em!important;}}/*!sc*/ .fkQbne.fkQbne.fkQbne.fkQbne{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.fkQbne.fkQbne.fkQbne.fkQbne{font-size:1.1em!important;}}/*!sc*/ .dlvuml.dlvuml.dlvuml.dlvuml{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.dlvuml.dlvuml.dlvuml.dlvuml{font-size:1.4em!important;}}/*!sc*/ .kzZypK.kzZypK.kzZypK.kzZypK{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kzZypK.kzZypK.kzZypK.kzZypK{font-size:1.3em!important;}}/*!sc*/ .hsCvVI.hsCvVI.hsCvVI.hsCvVI{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hsCvVI.hsCvVI.hsCvVI.hsCvVI{font-size:1.1em!important;}}/*!sc*/ .gIxNYc.gIxNYc.gIxNYc.gIxNYc{font-size:6.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.gIxNYc.gIxNYc.gIxNYc.gIxNYc{font-size:2.3em!important;}}/*!sc*/ .FTWnv.FTWnv.FTWnv.FTWnv{font-size:7.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.FTWnv.FTWnv.FTWnv.FTWnv{font-size:2.5em!important;}}/*!sc*/ .bAcObk.bAcObk.bAcObk.bAcObk{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bAcObk.bAcObk.bAcObk.bAcObk{font-size:1.3em!important;}}/*!sc*/ .hWUOar.hWUOar.hWUOar.hWUOar{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.hWUOar.hWUOar.hWUOar.hWUOar{font-size:1.3em!important;}}/*!sc*/ .LNGVh.LNGVh.LNGVh.LNGVh{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.LNGVh.LNGVh.LNGVh.LNGVh{font-size:1.7em!important;}}/*!sc*/ .ffRdGV.ffRdGV.ffRdGV.ffRdGV{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.ffRdGV.ffRdGV.ffRdGV.ffRdGV{font-size:2.2em!important;}}/*!sc*/ .cgtUoG.cgtUoG.cgtUoG.cgtUoG{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.cgtUoG.cgtUoG.cgtUoG.cgtUoG{font-size:1.4em!important;}}/*!sc*/ .ciVfIM.ciVfIM.ciVfIM.ciVfIM{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.ciVfIM.ciVfIM.ciVfIM.ciVfIM{font-size:1.2em!important;}}/*!sc*/ .klOlMp.klOlMp.klOlMp.klOlMp{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.klOlMp.klOlMp.klOlMp.klOlMp{font-size:1.8em!important;}}/*!sc*/ .clKRtz.clKRtz.clKRtz.clKRtz{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.clKRtz.clKRtz.clKRtz.clKRtz{font-size:1em!important;}}/*!sc*/ .cJqdVa.cJqdVa.cJqdVa.cJqdVa{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.cJqdVa.cJqdVa.cJqdVa.cJqdVa{font-size:1.5em!important;}}/*!sc*/ .iCKKfY.iCKKfY.iCKKfY.iCKKfY{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.iCKKfY.iCKKfY.iCKKfY.iCKKfY{font-size:1.9em!important;}}/*!sc*/ .eOoZPI.eOoZPI.eOoZPI.eOoZPI{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.eOoZPI.eOoZPI.eOoZPI.eOoZPI{font-size:2em!important;}}/*!sc*/ .cegAnz.cegAnz.cegAnz.cegAnz{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cegAnz.cegAnz.cegAnz.cegAnz{font-size:2.2em!important;}}/*!sc*/ .kmPMzO.kmPMzO.kmPMzO.kmPMzO{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kmPMzO.kmPMzO.kmPMzO.kmPMzO{font-size:1.6em!important;}}/*!sc*/ .dWYonX.dWYonX.dWYonX.dWYonX{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dWYonX.dWYonX.dWYonX.dWYonX{font-size:0.9em!important;}}/*!sc*/ .hwhwbf.hwhwbf.hwhwbf.hwhwbf{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.hwhwbf.hwhwbf.hwhwbf.hwhwbf{font-size:1.1em!important;}}/*!sc*/ .llJALx.llJALx.llJALx.llJALx{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.llJALx.llJALx.llJALx.llJALx{font-size:0.9em!important;}}/*!sc*/ .bwkOUE.bwkOUE.bwkOUE.bwkOUE{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwkOUE.bwkOUE.bwkOUE.bwkOUE{font-size:0.8em!important;}}/*!sc*/ .eRvGXV.eRvGXV.eRvGXV.eRvGXV{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.eRvGXV.eRvGXV.eRvGXV.eRvGXV{font-size:0.7em!important;}}/*!sc*/ .HdRfg.HdRfg.HdRfg.HdRfg{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.HdRfg.HdRfg.HdRfg.HdRfg{font-size:1.5em!important;}}/*!sc*/ .iGYvsS.iGYvsS.iGYvsS.iGYvsS{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.iGYvsS.iGYvsS.iGYvsS.iGYvsS{font-size:2.8em!important;}}/*!sc*/ .hODubF.hODubF.hODubF.hODubF{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.hODubF.hODubF.hODubF.hODubF{font-size:2.8em!important;}}/*!sc*/ .kBqyTx.kBqyTx.kBqyTx.kBqyTx{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kBqyTx.kBqyTx.kBqyTx.kBqyTx{font-size:2.1em!important;}}/*!sc*/ .iHowIZ.iHowIZ.iHowIZ.iHowIZ{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.iHowIZ.iHowIZ.iHowIZ.iHowIZ{font-size:2.3em!important;}}/*!sc*/ .bmELBo.bmELBo.bmELBo.bmELBo{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.bmELBo.bmELBo.bmELBo.bmELBo{font-size:1.4em!important;}}/*!sc*/ .ffHXiJ.ffHXiJ.ffHXiJ.ffHXiJ{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.ffHXiJ.ffHXiJ.ffHXiJ.ffHXiJ{font-size:1.9em!important;}}/*!sc*/ .MgtIT.MgtIT.MgtIT.MgtIT{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.MgtIT.MgtIT.MgtIT.MgtIT{font-size:1.7em!important;}}/*!sc*/ .dsMBkW.dsMBkW.dsMBkW.dsMBkW{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dsMBkW.dsMBkW.dsMBkW.dsMBkW{font-size:2em!important;}}/*!sc*/ .PHQVD.PHQVD.PHQVD.PHQVD{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.PHQVD.PHQVD.PHQVD.PHQVD{font-size:2em!important;}}/*!sc*/ .eQLhWV.eQLhWV.eQLhWV.eQLhWV{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQLhWV.eQLhWV.eQLhWV.eQLhWV{font-size:1.1em!important;}}/*!sc*/ .dGLeEg.dGLeEg.dGLeEg.dGLeEg{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.dGLeEg.dGLeEg.dGLeEg.dGLeEg{font-size:0.7em!important;}}/*!sc*/ .kxpFjY.kxpFjY.kxpFjY.kxpFjY{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kxpFjY.kxpFjY.kxpFjY.kxpFjY{font-size:0.6em!important;}}/*!sc*/ .kJRQSm.kJRQSm.kJRQSm.kJRQSm{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kJRQSm.kJRQSm.kJRQSm.kJRQSm{font-size:1.2em!important;}}/*!sc*/ .bDZeNq.bDZeNq.bDZeNq.bDZeNq{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bDZeNq.bDZeNq.bDZeNq.bDZeNq{font-size:1.7em!important;}}/*!sc*/ .GzVIy.GzVIy.GzVIy.GzVIy{font-size:11.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.GzVIy.GzVIy.GzVIy.GzVIy{font-size:4em!important;}}/*!sc*/ .dfsdVH.dfsdVH.dfsdVH.dfsdVH{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfsdVH.dfsdVH.dfsdVH.dfsdVH{font-size:2.6em!important;}}/*!sc*/ .efuKRI.efuKRI.efuKRI.efuKRI{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.efuKRI.efuKRI.efuKRI.efuKRI{font-size:1.6em!important;}}/*!sc*/ .jQWYqT.jQWYqT.jQWYqT.jQWYqT{font-size:12.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jQWYqT.jQWYqT.jQWYqT.jQWYqT{font-size:4.3em!important;}}/*!sc*/ .eWNmnq.eWNmnq.eWNmnq.eWNmnq{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.eWNmnq.eWNmnq.eWNmnq.eWNmnq{font-size:0.8em!important;}}/*!sc*/ .gNnpId.gNnpId.gNnpId.gNnpId{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gNnpId.gNnpId.gNnpId.gNnpId{font-size:1.5em!important;}}/*!sc*/ .gBUtip.gBUtip.gBUtip.gBUtip{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.gBUtip.gBUtip.gBUtip.gBUtip{font-size:1.7em!important;}}/*!sc*/ .gBCTAN.gBCTAN.gBCTAN.gBCTAN{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gBCTAN.gBCTAN.gBCTAN.gBCTAN{font-size:2.5em!important;}}/*!sc*/ .gYsYnd.gYsYnd.gYsYnd.gYsYnd{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gYsYnd.gYsYnd.gYsYnd.gYsYnd{font-size:2em!important;}}/*!sc*/ .eTyBWU.eTyBWU.eTyBWU.eTyBWU{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.eTyBWU.eTyBWU.eTyBWU.eTyBWU{font-size:2.1em!important;}}/*!sc*/ .brXUix.brXUix.brXUix.brXUix{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.brXUix.brXUix.brXUix.brXUix{font-size:0.6em!important;}}/*!sc*/ .bwgvhN.bwgvhN.bwgvhN.bwgvhN{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwgvhN.bwgvhN.bwgvhN.bwgvhN{font-size:2.1em!important;}}/*!sc*/ .cnmBLP.cnmBLP.cnmBLP.cnmBLP{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnmBLP.cnmBLP.cnmBLP.cnmBLP{font-size:1.5em!important;}}/*!sc*/ .dKgMyF.dKgMyF.dKgMyF.dKgMyF{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dKgMyF.dKgMyF.dKgMyF.dKgMyF{font-size:1.3em!important;}}/*!sc*/ .MBqIm.MBqIm.MBqIm.MBqIm{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.MBqIm.MBqIm.MBqIm.MBqIm{font-size:2.2em!important;}}/*!sc*/ .dAYobg.dAYobg.dAYobg.dAYobg{font-size:8.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dAYobg.dAYobg.dAYobg.dAYobg{font-size:2.9em!important;}}/*!sc*/ .SwyYl.SwyYl.SwyYl.SwyYl{font-size:11.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.SwyYl.SwyYl.SwyYl.SwyYl{font-size:4em!important;}}/*!sc*/ .feoVKA.feoVKA.feoVKA.feoVKA{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.feoVKA.feoVKA.feoVKA.feoVKA{font-size:0.5em!important;}}/*!sc*/ .bYhFDa.bYhFDa.bYhFDa.bYhFDa{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bYhFDa.bYhFDa.bYhFDa.bYhFDa{font-size:0.9em!important;}}/*!sc*/ .bKnDUs.bKnDUs.bKnDUs.bKnDUs{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bKnDUs.bKnDUs.bKnDUs.bKnDUs{font-size:1.1em!important;}}/*!sc*/ .jVOGmO.jVOGmO.jVOGmO.jVOGmO{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jVOGmO.jVOGmO.jVOGmO.jVOGmO{font-size:2.3em!important;}}/*!sc*/ .hSERGV.hSERGV.hSERGV.hSERGV{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.hSERGV.hSERGV.hSERGV.hSERGV{font-size:1.7em!important;}}/*!sc*/ .kgxnuC.kgxnuC.kgxnuC.kgxnuC{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.kgxnuC.kgxnuC.kgxnuC.kgxnuC{font-size:2em!important;}}/*!sc*/ .eAJKef.eAJKef.eAJKef.eAJKef{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.eAJKef.eAJKef.eAJKef.eAJKef{font-size:0.8em!important;}}/*!sc*/ .byeaVq.byeaVq.byeaVq.byeaVq{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.byeaVq.byeaVq.byeaVq.byeaVq{font-size:2.7em!important;}}/*!sc*/ .FjFyP.FjFyP.FjFyP.FjFyP{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.FjFyP.FjFyP.FjFyP.FjFyP{font-size:2.3em!important;}}/*!sc*/ .jItpJm.jItpJm.jItpJm.jItpJm{font-size:8.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jItpJm.jItpJm.jItpJm.jItpJm{font-size:2.9em!important;}}/*!sc*/ .syWhf.syWhf.syWhf.syWhf{font-size:9.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.syWhf.syWhf.syWhf.syWhf{font-size:3.4em!important;}}/*!sc*/ .iDNnFU.iDNnFU.iDNnFU.iDNnFU{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iDNnFU.iDNnFU.iDNnFU.iDNnFU{font-size:1.8em!important;}}/*!sc*/ .bPaEDz.bPaEDz.bPaEDz.bPaEDz{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bPaEDz.bPaEDz.bPaEDz.bPaEDz{font-size:1.1em!important;}}/*!sc*/ .SmgoK.SmgoK.SmgoK.SmgoK{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.SmgoK.SmgoK.SmgoK.SmgoK{font-size:0.7em!important;}}/*!sc*/ .fmKQUI.fmKQUI.fmKQUI.fmKQUI{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.fmKQUI.fmKQUI.fmKQUI.fmKQUI{font-size:1em!important;}}/*!sc*/ .bCpqdI.bCpqdI.bCpqdI.bCpqdI{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bCpqdI.bCpqdI.bCpqdI.bCpqdI{font-size:1.5em!important;}}/*!sc*/ .bFmwRb.bFmwRb.bFmwRb.bFmwRb{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bFmwRb.bFmwRb.bFmwRb.bFmwRb{font-size:0.6em!important;}}/*!sc*/ data-styled.g109[id=\"pt8tzk-0\"]{content:\"htNVWC,fEoqYx,mRkYR,kXXbDl,bvyTBk,lokTIa,dRlPwV,fpIjBV,fUMIho,jtRPEs,ckFdEF,fkQbne,dlvuml,kzZypK,hsCvVI,gIxNYc,FTWnv,bAcObk,hWUOar,LNGVh,ffRdGV,cgtUoG,ciVfIM,klOlMp,clKRtz,cJqdVa,iCKKfY,eOoZPI,cegAnz,kmPMzO,dWYonX,hwhwbf,llJALx,bwkOUE,eRvGXV,HdRfg,iGYvsS,hODubF,kBqyTx,iHowIZ,bmELBo,ffHXiJ,MgtIT,dsMBkW,PHQVD,eQLhWV,dGLeEg,kxpFjY,kJRQSm,bDZeNq,GzVIy,dfsdVH,efuKRI,jQWYqT,eWNmnq,gNnpId,gBUtip,gBCTAN,gYsYnd,eTyBWU,brXUix,bwgvhN,cnmBLP,dKgMyF,MBqIm,dAYobg,SwyYl,feoVKA,bYhFDa,bKnDUs,jVOGmO,hSERGV,kgxnuC,eAJKef,byeaVq,FjFyP,jItpJm,syWhf,iDNnFU,bPaEDz,SmgoK,fmKQUI,bCpqdI,bFmwRb,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard3&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Hvitere tenner: - Eneste som virker\" href=\"https://www.dagbladet.no/tema/hvitere-tenner---det-eneste-som-virker/73651236\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Hvitere tenner: - Eneste som virker\" alt=\"Image: Hvitere tenner: - Eneste som virker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73727442&amp;panoh=25.266903914591&amp;panoy=64.642857142857&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 htNVWC title dynamic-sizing\">Hvitere tenner:</span><span class=\"pt8tzk-0 fEoqYx title dynamic-sizing\">- Eneste som virker</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=\"Tror ikke det hun ser \" href=\"https://www.dagbladet.no/video/tror-ikke-det-hun-ser-/EfoAyJOb\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Tror ikke det hun ser \" alt=\"Image: Tror ikke det hun ser \" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/EfoAyJOb-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 mRkYR title dynamic-sizing\">Tror ikke</span><span class=\"pt8tzk-0 kXXbDl title dynamic-sizing\">det hun ser </span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Offentliggjør dødsårsaken\" href=\"https://www.dagbladet.no/kjendis/offentliggjor-dodsarsaken/73730964\"><figure class=\"sc-1an7vu1-0 beQEWY\"><picture><img data-defer=\"view\" title=\"Image: Offentliggjør dødsårsaken\" alt=\"Image: Offentliggjør dødsårsaken\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73731018&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=46.40522875817&amp;heightx=21.782178217822&amp;heightw=44.554455445545&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=254\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bvyTBk title dynamic-sizing\">Offentliggjør</span><span class=\"pt8tzk-0 bvyTBk title dynamic-sizing\">dødsårsaken</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører: - Hadde ikke sex\" href=\"https://www.dagbladet.no/kjendis/avslorer---hadde-ikke-sex/73731878\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Avslører: - Hadde ikke sex\" alt=\"Image: Avslører: - Hadde ikke sex\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73732049&amp;panoy=0&amp;panox=0&amp;panow=99.893674641148&amp;panoh=50.91926618705&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 lokTIa title dynamic-sizing\">Avslører:</span><span class=\"pt8tzk-0 dRlPwV title dynamic-sizing\">- Hadde ikke sex</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gjorde kjempefunn: – Utrolig\" href=\"https://www.dagbladet.no/nyheter/gjorde-kjempefunn--utrolig/73731843\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Gjorde kjempefunn: – Utrolig\" alt=\"Image: Gjorde kjempefunn: – Utrolig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73732024&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=50.95785440613&amp;heightw=34.48275862069&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fpIjBV title dynamic-sizing\">Gjorde kjempefunn:</span><span class=\"pt8tzk-0 fUMIho title dynamic-sizing\">– Utrolig</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Så døden i hvitøyet: Tilbake\" href=\"https://www.dagbladet.no/sport/sa-doden-i-hvitoyet-tilbake/73727978\"><figure class=\"sc-1an7vu1-0 jhCdqv\"><picture><img data-defer=\"view\" title=\"Image: Så døden i hvitøyet: Tilbake\" alt=\"Image: Så døden i hvitøyet: Tilbake\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73728385&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=485&amp;height=243\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 jtRPEs title dynamic-sizing\">Så døden i</span><span class=\"pt8tzk-0 ckFdEF title dynamic-sizing\">hvitøyet: Tilbake</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=\"Fant tonen i hemmelighet\" href=\"https://www.dagbladet.no/video/fant-tonen-i-hemmelighet/azob0R7N\"><figure class=\"sc-1an7vu1-0 gqRXqT\"><picture><img data-defer=\"view\" title=\"Image: Fant tonen i hemmelighet\" alt=\"Image: Fant tonen i hemmelighet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/azob0R7N-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kXXbDl title dynamic-sizing\">Fant tonen i</span><span class=\"pt8tzk-0 fkQbne title dynamic-sizing\">hemmelighet</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=\"Eksperter: Slik fjerner du armfettet\" href=\"https://www.dagbladet.no/tema/ovelsene-for-a-fjerne-armfettet/72549540\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Eksperter: Slik fjerner du armfettet\" alt=\"Image: Eksperter: Slik fjerner du armfettet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=72550626&amp;panoy=63.97037037037&amp;panox=0.46657962962963&amp;panow=100.46657962963&amp;panoh=33.799912962963&amp;heighty=0.005105882352942&amp;heightw=61.443014379085&amp;heighth=100.00510588235&amp;heightx=31.372549019608&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dlvuml title dynamic-sizing\">Eksperter:</span><span class=\"pt8tzk-0 kzZypK title dynamic-sizing\">Slik fjerner</span><span class=\"pt8tzk-0 hsCvVI title dynamic-sizing\">du armfettet</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle3&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nick Kamen (59) er død\" href=\"https://www.dagbladet.no/kjendis/nick-kamen-59-er-dod/73730195\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Nick Kamen (59) er død\" alt=\"Image: Nick Kamen (59) er død\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73730331&amp;panoy=24.605678233438&amp;panox=0&amp;panow=100&amp;panoh=22.397476340694&amp;heightw=77.586206896552&amp;heighth=83.522727272727&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gIxNYc title dynamic-sizing\">Nick Kamen</span><span class=\"pt8tzk-0 FTWnv title dynamic-sizing\">(59) er død</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Stjernedøtrene ikke på talefot\" href=\"https://www.dagbladet.no/kjendis/stjernedotrene-ikke-pa-talefot/73730109\"><figure class=\"sc-1an7vu1-0 cKiVil\"><picture><img data-defer=\"view\" title=\"Image: Stjernedøtrene ikke på talefot\" alt=\"Image: Stjernedøtrene ikke på talefot\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73723971&amp;panoy=13.13672922252&amp;panox=6.0240963855422&amp;panow=83.935742971888&amp;panoh=19.034852546917&amp;heighty=4.1666666666667&amp;heightw=62.937062937063&amp;heighth=68.055555555556&amp;heightx=18.181818181818&amp;width=402&amp;height=380\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bAcObk title dynamic-sizing\">Stjernedøtrene</span><span class=\"pt8tzk-0 hWUOar title dynamic-sizing\">ikke på talefot</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Til å spy av\" href=\"https://www.dagbladet.no/kultur/til-a-spy-av/73729641\"><figure class=\"sc-1an7vu1-0 kdXjqn\"><picture><img data-defer=\"view\" title=\"Image: Til å spy av\" alt=\"Image: Til å spy av\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73734000&amp;panow=64.220183486239&amp;panoh=32.718894009217&amp;panox=20.489296636086&amp;panoy=23.963133640553&amp;heighty=17.204301075269&amp;heightx=38.214285714286&amp;heightw=32.142857142857&amp;heighth=79.032258064516&amp;width=402&amp;height=366\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"dice-wrap\"><svg class=\"dice\" width=\"100%\" height=\"100%\" viewBox=\"0 0 100 100\" preserveAspectRatio=\"none\"><rect class=\"face\" x=\"0\" y=\"0\" width=\"100\" height=\"100\"></rect><path class=\"face-shade\" d=\"M 0 0 L 100 0 L 0 100 z\"></path><circle class=\"pip\" cx=\"25\" cy=\"75\" r=\"10\"></circle><circle class=\"pip\" cx=\"50\" cy=\"50\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"25\" r=\"10\"></circle></svg></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 LNGVh title dynamic-sizing\">Til å spy av</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Prins skjøt Europas største bjørn\" href=\"https://www.dagbladet.no/kjendis/prins-skjot-europas-storste-bjorn/73731622\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Prins skjøt Europas største bjørn\" alt=\"Image: Prins skjøt Europas største bjørn\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73731750&amp;panox=0&amp;panow=99.893674641148&amp;panoh=50.91926618705&amp;panoy=17.26618705036&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 ckFdEF title dynamic-sizing\">Prins skjøt Europas</span><span class=\"pt8tzk-0 ffRdGV title dynamic-sizing\">største bjørn</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard4&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Deler seg i to: - Dæven!\" href=\"https://www.dagbladet.no/video/deler-seg-i-to-daeven/JpSmUlVP\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Deler seg i to: - Dæven!\" alt=\"Image: Deler seg i to: - Dæven!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/JpSmUlVP-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cgtUoG title dynamic-sizing\">Deler seg i</span><span class=\"pt8tzk-0 ciVfIM title dynamic-sizing\">to: - Dæven!</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=\"Har ikke sittet på 25 år\" href=\"https://www.dagbladet.no/tema/arild-ronsen-65-ikke-sittet-pa-25-ar/73613987\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Har ikke sittet på 25 år\" alt=\"Image: Har ikke sittet på 25 år\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73647633&amp;panoy=25&amp;panow=24.390243902439&amp;panoh=12.412587412587&amp;panox=19.396051103368&amp;heightx=22.761194029851&amp;heightw=16.791044776119&amp;heighth=41.176470588235&amp;heighty=20.168067226891&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 klOlMp title dynamic-sizing\">Har ikke</span><span class=\"pt8tzk-0 clKRtz title dynamic-sizing\">sittet på 25 år</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Melder avbud\" href=\"https://www.dagbladet.no/kjendis/melder-avbud/73734498\"><figure class=\"sc-1an7vu1-0 iUvBjr\"><picture><img data-defer=\"view\" title=\"Image: Melder avbud\" alt=\"Image: Melder avbud\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73734501&amp;panox=0&amp;panow=100&amp;panoh=26.492537313433&amp;panoy=6.3432835820896&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=296\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 LNGVh title dynamic-sizing\">Melder avbud</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Drepte broren i sin egen bursdag\" href=\"https://www.dagbladet.no/nyheter/drepte-broren-i-sin-egen-bursdag/73729673\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Drepte broren i sin egen bursdag\" alt=\"Image: Drepte broren i sin egen bursdag\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73723833&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cJqdVa title dynamic-sizing\">Drepte broren i</span><span class=\"pt8tzk-0 kzZypK title dynamic-sizing\">sin egen bursdag</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sjakk-kollega: - Formidabelt dyktig dame\" href=\"https://www.dagbladet.no/sport/sjakk-kollega---formidabelt-dyktig-dame/73728011\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Sjakk-kollega: - Formidabelt dyktig dame\" alt=\"Image: Sjakk-kollega: - Formidabelt dyktig dame\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73728066&amp;panoy=10.714285714286&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=40.723981900452&amp;heighty=0&amp;heightx=32.126696832579&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 iCKKfY title dynamic-sizing\">Sjakk-kollega:</span><span class=\"pt8tzk-0 eOoZPI title dynamic-sizing\">- Formidabelt</span><span class=\"pt8tzk-0 cegAnz title dynamic-sizing\">dyktig dame</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Klager Norge inn for EMD\" href=\"https://www.dagbladet.no/nyheter/klager-norge-inn-for-emd/73735297\"><figure class=\"sc-1an7vu1-0 jmOGNB\"><picture><img data-defer=\"view\" title=\"Image: Klager Norge inn for EMD\" alt=\"Image: Klager Norge inn for EMD\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73735317&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=46.153846153846&amp;heightw=40.723981900452&amp;heighth=100&amp;width=402&amp;height=417\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dlvuml title dynamic-sizing\">Klager Norge</span><span class=\"pt8tzk-0 kmPMzO title dynamic-sizing\">inn for EMD</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=\"Absurd hendelse i bokseringen\" href=\"https://www.dagbladet.no/video/absurd-hendelse-i-bokseringen/Wfs0vTzf\"><figure class=\"sc-1an7vu1-0 fwhPIB\"><picture><img data-defer=\"view\" title=\"Image: Absurd hendelse i bokseringen\" alt=\"Image: Absurd hendelse i bokseringen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Wfs0vTzf-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dWYonX title dynamic-sizing\">Absurd hendelse</span><span class=\"pt8tzk-0 hwhwbf title dynamic-sizing\">i bokseringen</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Studie: Effektiv medisin mot corona\" href=\"https://www.dagbladet.no/nyheter/studie-effektiv-medisin-mot-corona/73653062\"><figure class=\"sc-1an7vu1-0 hYmQsU\"><picture><img data-defer=\"view\" title=\"Image: Studie: Effektiv medisin mot corona\" alt=\"Image: Studie: Effektiv medisin mot corona\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73666307&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=204\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 llJALx title dynamic-sizing\">Studie: Effektiv</span><span class=\"pt8tzk-0 fEoqYx title dynamic-sizing\">medisin mot corona</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=\"Derfor er det lurt å refinansiere dyr gjeld\" href=\"https://www.dagbladet.no/annonse/derfor-er-det-lurt-a-refinansiere-dyr-gjeld/73622499\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/03/20/allerlogo.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Derfor er det lurt å refinansiere dyr gjeld\" alt=\"Image: Derfor er det lurt å refinansiere dyr gjeld\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/73622515.jpg?imageId=73622515&amp;x=0.000000&amp;y=13.169985&amp;cropw=100.000000&amp;croph=86.830015&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bwkOUE title dynamic-sizing\">Derfor er det lurt å</span><span class=\"pt8tzk-0 eRvGXV title dynamic-sizing\">refinansiere dyr gjeld</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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ønsker gammel RBK-helt\" href=\"https://www.dagbladet.no/sport/onsker-gammel-rbk-helt/73733983\"><figure class=\"sc-1an7vu1-0 icWpRL\"><picture><img data-defer=\"view\" title=\"Image: Ønsker gammel RBK-helt\" alt=\"Image: Ønsker gammel RBK-helt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73734004&amp;panoy=11.157024793388&amp;panox=38.736263736264&amp;panow=57.148580769231&amp;panoh=29.226680658436&amp;heighty=0.014269863013704&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;heightx=43.37899543379&amp;width=485&amp;height=253\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 HdRfg title dynamic-sizing\">Ønsker gammel</span><span class=\"pt8tzk-0 lokTIa title dynamic-sizing\">RBK-helt</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ugjenkjennelig: - Brutalt\" href=\"https://www.dagbladet.no/kjendis/ugjenkjennelig---brutalt/73732713\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Ugjenkjennelig: - Brutalt\" alt=\"Image: Ugjenkjennelig: - Brutalt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73733111&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;panoy=37.58865248227&amp;heightw=40.723981900452&amp;heighty=0&amp;heightx=40.723981900452&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 HdRfg title dynamic-sizing\">Ugjenkjennelig:</span><span class=\"pt8tzk-0 iGYvsS title dynamic-sizing\">- Brutalt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Flaut å være norsk\" href=\"https://www.dagbladet.no/nyheter/flaut-a-vaere-norsk/73733382\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: - Flaut å være norsk\" alt=\"Image: - Flaut å være norsk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73375523&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 hODubF title dynamic-sizing\">- Flaut å</span><span class=\"pt8tzk-0 kBqyTx title dynamic-sizing\">være norsk</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Det er Kina, din tulling\" href=\"https://www.dagbladet.no/meninger/det-er-kina-din-tulling/73723555\"><figure class=\"sc-1an7vu1-0 MGCdC\"><picture><img data-defer=\"view\" title=\"Image: Det er Kina, din tulling\" alt=\"Image: Det er Kina, din tulling\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73684170&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=273\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 eOoZPI title dynamic-sizing\">Det er Kina,</span><span class=\"pt8tzk-0 iHowIZ title dynamic-sizing\">din tulling</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard5&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Livet etter bruddet\" href=\"https://www.dagbladet.no/magasinet/livet-etter-bruddet/73563343\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Livet etter bruddet\" alt=\"Image: Livet etter bruddet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73564191&amp;panox=0&amp;panow=100&amp;panoh=26.996197718631&amp;panoy=26.615969581749&amp;heighty=0&amp;heightx=20.289855072464&amp;heightw=65.217391304348&amp;heighth=85.964912280702&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bmELBo title dynamic-sizing\">Livet etter</span><span class=\"pt8tzk-0 ffHXiJ title dynamic-sizing\">bruddet</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=\"- Idiot\" href=\"https://www.dagbladet.no/video/-idiot/N3lawm83\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: - Idiot\" alt=\"Image: - Idiot\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/N3lawm83-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fUMIho title dynamic-sizing\">- Idiot</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Supporternes bønn - Vil ha Haaland\" href=\"https://www.dagbladet.no/sport/supporternes-bonn---vil-ha-haaland/73725972\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Supporternes bønn - Vil ha Haaland\" alt=\"Image: Supporternes bønn - Vil ha Haaland\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73726090&amp;panoy=2.8571428571429&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightx=14.47963800905&amp;heightw=40.723981900452&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cgtUoG title dynamic-sizing\">Supporternes bønn</span><span class=\"pt8tzk-0 LNGVh title dynamic-sizing\">- Vil ha Haaland</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kane (118) trakk seg\" href=\"https://www.dagbladet.no/nyheter/kane-118-trakk-seg/73730766\"><figure class=\"sc-1an7vu1-0 hzTaYt\"><picture><img data-defer=\"view\" title=\"Image: Kane (118) trakk seg\" alt=\"Image: Kane (118) trakk seg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73730779&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=34.254143646409&amp;heightw=49.723756906077&amp;width=402&amp;height=252\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 MgtIT title dynamic-sizing\">Kane (118)</span><span class=\"pt8tzk-0 dsMBkW title dynamic-sizing\">trakk seg</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- India og Sør-Afrika er sjokkert over Norge\" href=\"https://www.dagbladet.no/nyheter/india-og-sor-afrika-er-sjokkert-over-norge/73732093\"><figure class=\"sc-1an7vu1-0 gOIElM\"><picture><img data-defer=\"view\" title=\"Image: - India og Sør-Afrika er sjokkert over Norge\" alt=\"Image: - India og Sør-Afrika er sjokkert over Norge\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73732241&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=355\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dWYonX title dynamic-sizing\">- India og Sør-Afrika</span><span class=\"pt8tzk-0 bwkOUE title dynamic-sizing\">er sjokkert over Norge</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Knivstakk politimann elleve ganger\" href=\"https://www.dagbladet.no/nyheter/knivstakk-politimann-elleve-ganger/73731926\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Knivstakk politimann elleve ganger\" alt=\"Image: Knivstakk politimann elleve ganger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73732186&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=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bAcObk title dynamic-sizing\">Knivstakk politimann</span><span class=\"pt8tzk-0 PHQVD title dynamic-sizing\">elleve ganger</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=\"Fikk ubuden gjest på døra\" href=\"https://www.dagbladet.no/video/fikk-ubuden-gjest-pa-dora/oEiCJDVZ\"><figure class=\"sc-1an7vu1-0 iefiXl\"><picture><img data-defer=\"view\" title=\"Image: Fikk ubuden gjest på døra\" alt=\"Image: Fikk ubuden gjest på døra\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/oEiCJDVZ-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 ciVfIM title dynamic-sizing\">Fikk ubuden</span><span class=\"pt8tzk-0 eQLhWV title dynamic-sizing\">gjest på døra</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=\"Ned ti kilo før sommeren\" href=\"https://www.dagbladet.no/tema/oppskriften-ned-ti-kilo-pa-ti-uker/73547905\"><figure class=\"sc-1an7vu1-0 bIVEDS\"><picture><img data-defer=\"view\" title=\"Image: Ned ti kilo før sommeren\" alt=\"Image: Ned ti kilo før sommeren\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73561208&amp;panoy=11.797752808989&amp;panox=0&amp;panow=100&amp;panoh=39.887640449438&amp;heightx=39.776951672862&amp;heightw=33.457249070632&amp;heighth=64.192139737991&amp;heighty=7.8602620087336&amp;width=320&amp;height=162\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bmELBo title dynamic-sizing\">Ned ti kilo</span><span class=\"pt8tzk-0 clKRtz title dynamic-sizing\">før sommeren</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=\"Bli kvitt inkasso og betalingsanmerkninger\" href=\"https://www.dagbladet.no/annonse/refinansier-dyr-gjeld---spar-penger/73659872\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/03/20/allerlogo.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Bli kvitt inkasso og betalingsanmerkninger\" alt=\"Image: Bli kvitt inkasso og betalingsanmerkninger\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/73659906.jpg?imageId=73659906&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=100.000000&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dGLeEg title dynamic-sizing\">Bli kvitt inkasso og</span><span class=\"pt8tzk-0 kxpFjY title dynamic-sizing\">betalingsanmerkninger</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Etterlyser vitner: - Tankeløs spøk\" href=\"https://www.dagbladet.no/nyheter/etterlyser-vitner---tankelos-spok/73727616\"><figure class=\"sc-1an7vu1-0 dFjCVh\"><picture><img data-defer=\"view\" title=\"Image: Etterlyser vitner: - Tankeløs spøk\" alt=\"Image: Etterlyser vitner: - Tankeløs spøk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73731591&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=264\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fkQbne title dynamic-sizing\">Etterlyser vitner:</span><span class=\"pt8tzk-0 kJRQSm title dynamic-sizing\">- Tankeløs spøk</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fødte «nilinger»\" href=\"https://www.dagbladet.no/nyheter/fodte-nilinger/73727059\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Fødte «nilinger»\" alt=\"Image: Fødte «nilinger»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73727242&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;heightx=5.8823529411765&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bDZeNq title dynamic-sizing\">Fødte «nilinger»</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skjulte graviditeten\" href=\"https://www.dagbladet.no/kjendis/skjulte-graviditeten/73727786\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Skjulte graviditeten\" alt=\"Image: Skjulte graviditeten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73728635&amp;panoy=3.448275862069&amp;panow=100&amp;panoh=61.206896551724&amp;panox=0&amp;heighty=0&amp;heightx=43.445692883895&amp;heightw=33.707865168539&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 GzVIy title dynamic-sizing\">Skjulte</span><span class=\"pt8tzk-0 gIxNYc title dynamic-sizing\">graviditeten</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Varsler karrierestopp\" href=\"https://www.dagbladet.no/sport/varsler-karrierestopp/73728752\"><figure class=\"sc-1an7vu1-0 hGEcXL\"><picture><img data-defer=\"view\" title=\"Image: Varsler karrierestopp\" alt=\"Image: Varsler karrierestopp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73728803&amp;panoh=51.079136690647&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=379\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dfsdVH title dynamic-sizing\">Varsler</span><span class=\"pt8tzk-0 cgtUoG title dynamic-sizing\">karrierestopp</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-12 medium-12 large-12 \" data-from=\"xavier\"><div id=\"ad-smartbanner1\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600], [980,300], [970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;smartbanner1&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Et ekstremt angrep på Arbeiderpartiet\" href=\"https://www.dagbladet.no/meninger/et-ekstremt-angrep-pa-arbeiderpartiet/73733773\"><figure class=\"sc-1an7vu1-0 gBSNQe\"><picture><img data-defer=\"view\" title=\"Image: Et ekstremt angrep på Arbeiderpartiet\" alt=\"Image: Et ekstremt angrep på Arbeiderpartiet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73734053&amp;panoy=6.3953488372093&amp;panox=13.178294573643&amp;panow=81.399753488372&amp;panoh=41.285676744186&amp;heightw=41.101079452055&amp;heighth=100.00778356164&amp;heighty=0.0077835616438261&amp;heightx=45.662100456621&amp;width=485&amp;height=266\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kJRQSm title dynamic-sizing\">Et ekstremt angrep</span><span class=\"pt8tzk-0 ciVfIM title dynamic-sizing\">på Arbeiderpartiet</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Krigshule funnet etter hundre år\" href=\"https://www.dagbladet.no/nyheter/krigshule-funnet-etter-hundre-ar/73727668\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Krigshule funnet etter hundre år\" alt=\"Image: Krigshule funnet etter hundre år\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73728849&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 ckFdEF title dynamic-sizing\">Krigshule funnet</span><span class=\"pt8tzk-0 efuKRI title dynamic-sizing\">etter hundre år</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Bestevennen savnet: - Har det vondt\" href=\"https://www.dagbladet.no/nyheter/forsvant/73728698\"><figure class=\"sc-1an7vu1-0 iOPyOl\"><picture><img data-defer=\"view\" title=\"Image: Bestevennen savnet: - Har det vondt\" alt=\"Image: Bestevennen savnet: - Har det vondt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73729752&amp;panox=0&amp;panow=100&amp;panoh=25.357142857143&amp;panoy=23.928571428571&amp;heighty=0&amp;heightx=14.545454545455&amp;heightw=81.818181818182&amp;heighth=100&amp;width=402&amp;height=481\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dWYonX title dynamic-sizing\">Bestevennen savnet:</span><span class=\"pt8tzk-0 ciVfIM title dynamic-sizing\">- Har det vondt</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Endrer navn - igjen\" href=\"https://www.dagbladet.no/kjendis/endrer-navn---igjen/73726418\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Endrer navn - igjen\" alt=\"Image: Endrer navn - igjen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73726505&amp;panox=0&amp;panow=100&amp;panoh=47.651006711409&amp;panoy=4.6979865771812&amp;heighty=0&amp;heightx=36.057692307692&amp;heightw=43.269230769231&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gIxNYc title dynamic-sizing\">Endrer navn</span><span class=\"pt8tzk-0 jQWYqT title dynamic-sizing\">- igjen</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=\"Besatt av livsfarlig operasjon\" href=\"https://www.dagbladet.no/tema/natasha-28-besatt-av-livsfarlig-operasjon/73571856\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Besatt av livsfarlig operasjon\" alt=\"Image: Besatt av livsfarlig operasjon\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73595579&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kmPMzO title dynamic-sizing\">Besatt av</span><span class=\"pt8tzk-0 MgtIT title dynamic-sizing\">livsfarlig</span><span class=\"pt8tzk-0 cJqdVa title dynamic-sizing\">operasjon</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=\"Skrekkvideo sett av millioner\" href=\"https://www.dagbladet.no/video/skrekkvideo-sett-av-millioner/Ag9a9ERE\"><figure class=\"sc-1an7vu1-0 Xowsl\"><picture><img data-defer=\"view\" title=\"Image: Skrekkvideo sett av millioner\" alt=\"Image: Skrekkvideo sett av millioner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Ag9a9ERE-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 eWNmnq title dynamic-sizing\">Skrekkvideo sett</span><span class=\"pt8tzk-0 kXXbDl title dynamic-sizing\">av millioner</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle4\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle4&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Raser: «Nær en krigshandling»\" href=\"https://www.dagbladet.no/nyheter/raser-naer-en-krigshandling/73731007\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Raser: «Nær en krigshandling»\" alt=\"Image: Raser: «Nær en krigshandling»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73731428&amp;panoy=21.428571428571&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gNnpId title dynamic-sizing\">Raser: «Nær en</span><span class=\"pt8tzk-0 efuKRI title dynamic-sizing\">krigshandling»</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Preges av fallet\" href=\"https://www.dagbladet.no/sport/preges-av-fallet/73727063\"><figure class=\"sc-1an7vu1-0 eenqZc\"><picture><img data-defer=\"view\" title=\"Image: Preges av fallet\" alt=\"Image: Preges av fallet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73731103&amp;panox=6.8441064638783&amp;panow=79.095374144487&amp;panoh=40.583333714286&amp;panoy=12&amp;heightx=29.72027972028&amp;heightw=31.126165734266&amp;heighth=76.450698429319&amp;heighty=9.4240837696335&amp;width=485&amp;height=315\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 HdRfg title dynamic-sizing\">Preges av fallet</span></h3></header></a></article></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=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vurderer bruk i butikker\" href=\"https://www.dagbladet.no/nyheter/vurderer-bruk-i-butikker/73729762\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Vurderer bruk i butikker\" alt=\"Image: Vurderer bruk i butikker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73730274&amp;panoh=51.824817518248&amp;panoy=32.116788321168&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=21.238938053097&amp;heightw=39.823008849558&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gBUtip title dynamic-sizing\">Vurderer bruk</span><span class=\"pt8tzk-0 gBCTAN title dynamic-sizing\">i butikker</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Angrer bare på én ting\" href=\"https://www.dagbladet.no/nyheter/angrer-bare-pa-n-ting/73727354\"><figure class=\"sc-1an7vu1-0 flPIvJ\"><picture><img data-defer=\"view\" title=\"Image: Angrer bare på én ting\" alt=\"Image: Angrer bare på én ting\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73727177&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=244\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gYsYnd title dynamic-sizing\">Angrer bare</span><span class=\"pt8tzk-0 cegAnz title dynamic-sizing\">på én ting</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard6&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Sett av millioner\" href=\"https://www.dagbladet.no/video/sett-av-millioner/eCracgg9\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Sett av millioner\" alt=\"Image: Sett av millioner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/eCracgg9-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 eTyBWU title dynamic-sizing\">Sett av</span><span class=\"pt8tzk-0 MgtIT title dynamic-sizing\">millioner</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=\"Einar (38) overvant depresjonen: - Fikk jobb\" href=\"https://www.dagbladet.no/tema/einar-38-overvant-depresjonen---fikk-jobb/73722293\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Einar (38) overvant depresjonen: - Fikk jobb\" alt=\"Image: Einar (38) overvant depresjonen: - Fikk jobb\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73728973&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighth=100&amp;heighty=0&amp;heightx=14.347826086957&amp;heightw=40.869565217391&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dGLeEg title dynamic-sizing\">Einar (38) overvant</span><span class=\"pt8tzk-0 brXUix title dynamic-sizing\">depresjonen: - Fikk jobb</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nå kan du se egen vaksinasjonsstatus\" href=\"https://www.dagbladet.no/nyheter/na-kan-du-se-egen-vaksinasjonsstatus/73729247\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Nå kan du se egen vaksinasjonsstatus\" alt=\"Image: Nå kan du se egen vaksinasjonsstatus\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73690125&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 HdRfg title dynamic-sizing\">Nå kan du se egen</span><span class=\"pt8tzk-0 ckFdEF title dynamic-sizing\">vaksinasjonsstatus</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Spår ellevill gullkamp\" href=\"https://www.dagbladet.no/sport/spar-ellevill-gullkamp/73732237\"><figure class=\"sc-1an7vu1-0 cFJCDt\"><picture><img data-defer=\"view\" title=\"Image: Spår ellevill gullkamp\" alt=\"Image: Spår ellevill gullkamp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73733102&amp;panoy=6.953642384106&amp;panox=27.87610619469&amp;panow=46.46017699115&amp;panoh=23.58803986711&amp;heightw=35.15625&amp;heighth=85.964912280702&amp;heighty=0&amp;heightx=31.25&amp;width=402&amp;height=243\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kmPMzO title dynamic-sizing\">Spår ellevill</span><span class=\"pt8tzk-0 bwgvhN title dynamic-sizing\">gullkamp</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vitne avbrøt overfallsvoldtekt\" href=\"https://www.dagbladet.no/nyheter/vitne-avbrot-overfallsvoldtekt/73734572\"><figure class=\"sc-1an7vu1-0 jiWEZa\"><picture><img data-defer=\"view\" title=\"Image: Vitne avbrøt overfallsvoldtekt\" alt=\"Image: Vitne avbrøt overfallsvoldtekt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73734637&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=276\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cnmBLP title dynamic-sizing\">Vitne avbrøt</span><span class=\"pt8tzk-0 hwhwbf title dynamic-sizing\">overfallsvoldtekt</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Forsker advarer: - En sovende klimabombe\" href=\"https://www.dagbladet.no/nyheter/forsker-advarer---en-sovende-klimabombe/73716156\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Forsker advarer: - En sovende klimabombe\" alt=\"Image: Forsker advarer: - En sovende klimabombe\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73716681&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=50.704225352113&amp;heightx=0&amp;heightw=41.284403669725&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bAcObk title dynamic-sizing\">Forsker advarer: - En</span><span class=\"pt8tzk-0 dKgMyF title dynamic-sizing\">sovende klimabombe</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Plutselig kommer denne\" href=\"https://www.dagbladet.no/video/plutselig-kommer-denne/bDCtGUYD\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Plutselig kommer denne\" alt=\"Image: Plutselig kommer denne\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/bDCtGUYD-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 LNGVh title dynamic-sizing\">Plutselig</span><span class=\"pt8tzk-0 htNVWC title dynamic-sizing\">kommer denne</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=\"Hvit pappvin: Nykommer imponerer!\" href=\"https://www.dagbladet.no/tema/hvit-pappvin-nykommer-imponerer/73634299\"><figure class=\"sc-1an7vu1-0 dcUdQe\"><picture><img data-defer=\"view\" title=\"Image: Hvit pappvin: Nykommer imponerer!\" alt=\"Image: Hvit pappvin: Nykommer imponerer!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73636741&amp;panoy=18.181818181818&amp;panox=0&amp;panow=100&amp;panoh=81.818181818182&amp;heightw=25.698324022346&amp;heighth=100&amp;heighty=0&amp;heightx=31.284916201117&amp;width=320&amp;height=201\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fkQbne title dynamic-sizing\">Hvit pappvin:</span><span class=\"pt8tzk-0 kxpFjY title dynamic-sizing\">Nykommer imponerer!</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle5\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle5&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ble kvalm av meg selv\" href=\"https://www.dagbladet.no/kjendis/ble-kvalm-av-meg-selv/73726850\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: - Ble kvalm av meg selv\" alt=\"Image: - Ble kvalm av meg selv\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73727513&amp;panow=99.893163461538&amp;panoh=22.364673076923&amp;panoy=20.205576923077&amp;panox=0&amp;heighty=8.6716588314305&amp;heightx=0&amp;heightw=100&amp;heighth=40.22834116857&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 PHQVD title dynamic-sizing\">- Ble kvalm</span><span class=\"pt8tzk-0 gYsYnd title dynamic-sizing\">av meg selv</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vil forandre Snehvit-slutten\" href=\"https://www.dagbladet.no/kultur/vil-forandre-snehvit-slutten/73727475\"><figure class=\"sc-1an7vu1-0 gBSNQe\"><picture><img data-defer=\"view\" title=\"Image: Vil forandre Snehvit-slutten\" alt=\"Image: Vil forandre Snehvit-slutten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73727531&amp;panow=100&amp;panoh=61.016949152542&amp;panoy=28.813559322034&amp;panox=0&amp;heighty=0&amp;heightx=26.335877862595&amp;heightw=34.351145038168&amp;heighth=100&amp;width=485&amp;height=266\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gYsYnd title dynamic-sizing\">Vil forandre</span><span class=\"pt8tzk-0 gNnpId title dynamic-sizing\">Snehvit-slutten</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ikke vært flink nok\" href=\"https://www.dagbladet.no/sport/ikke-vaert-flink-nok/73728833\"><figure class=\"sc-1an7vu1-0 pQzcV\"><picture><img data-defer=\"view\" title=\"Image: - Ikke vært flink nok\" alt=\"Image: - Ikke vært flink nok\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73733358&amp;panoy=32.142857142857&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=52.941176470588&amp;width=402&amp;height=407\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bDZeNq title dynamic-sizing\">- Ikke vært</span><span class=\"pt8tzk-0 MBqIm title dynamic-sizing\">flink nok</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ventetida er over\" href=\"https://www.dagbladet.no/kultur/ventetida-er-over/73730645\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Ventetida er over\" alt=\"Image: Ventetida er over\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73730717&amp;panoy=22.222222222222&amp;panox=3.4883720930233&amp;panow=81.395348837209&amp;panoh=41.520467836257&amp;heighty=24.019607843137&amp;heightx=14.239482200647&amp;heightw=29.126213592233&amp;heighth=72.058823529412&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dAYobg title dynamic-sizing\">Ventetida</span><span class=\"pt8tzk-0 SwyYl title dynamic-sizing\">er over</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard7&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Negative tilbakemeldinger: Tar skylden selv\" href=\"https://www.dagbladet.no/tema/negative-tilbakemeldinger-tar-skylden-selv/73717459\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Negative tilbakemeldinger: Tar skylden selv\" alt=\"Image: Negative tilbakemeldinger: Tar skylden selv\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73717626&amp;panoy=28.064516129032&amp;panox=0.46657962962963&amp;panow=100.46657962963&amp;panoh=23.550907096774&amp;heighty=26.746506986028&amp;heightw=27.327852325581&amp;heighth=30.479643824701&amp;heightx=35.174418604651&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 feoVKA title dynamic-sizing\">Negative tilbakemeldinger:</span><span class=\"pt8tzk-0 bYhFDa title dynamic-sizing\">Tar skylden selv</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advares: - Ikke gjør dette!\" href=\"https://www.dagbladet.no/video/advares-ikke-gjor-dette/wRRq2BWH\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Advares: - Ikke gjør dette!\" alt=\"Image: Advares: - Ikke gjør dette!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/wRRq2BWH-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 llJALx title dynamic-sizing\">Advares: - Ikke</span><span class=\"pt8tzk-0 bmELBo title dynamic-sizing\">gjør dette!</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører sykdomsdrama: - Gråt på innskytinga\" href=\"https://www.dagbladet.no/sport/avslorer-sykdomsdrama---grat-pa-innskytinga/73730853\"><figure class=\"sc-1an7vu1-0 eRlIuJ\"><picture><img data-defer=\"view\" title=\"Image: Avslører sykdomsdrama: - Gråt på innskytinga\" alt=\"Image: Avslører sykdomsdrama: - Gråt på innskytinga\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73730942&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=286\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dWYonX title dynamic-sizing\">Avslører sykdomsdrama:</span><span class=\"pt8tzk-0 bKnDUs title dynamic-sizing\">- Gråt på innskytinga</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tusenvis samlet i religiøst ritual\" href=\"https://www.dagbladet.no/nyheter/tusenvis-samlet-i-religiost-ritual/73732085\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Tusenvis samlet i religiøst ritual\" alt=\"Image: Tusenvis samlet i religiøst ritual\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73732400&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 hWUOar title dynamic-sizing\">Tusenvis samlet i</span><span class=\"pt8tzk-0 kmPMzO title dynamic-sizing\">religiøst ritual</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=\"Skyter\" href=\"https://www.dagbladet.no/video/skyter/Lyuz1HFT\"><figure class=\"sc-1an7vu1-0 cOHzME\"><picture><img data-defer=\"view\" title=\"Image: Skyter\" alt=\"Image: Skyter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Lyuz1HFT-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 jVOGmO title dynamic-sizing\">Skyter</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=\"22 år på lukket avdeling\" href=\"https://www.dagbladet.no/tema/sadistens-22-ar-pa-lukket-avdeling/73599347\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: 22 år på lukket avdeling\" alt=\"Image: 22 år på lukket avdeling\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73619196&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=25&amp;heightw=41.666666666667&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 hSERGV title dynamic-sizing\">22 år på</span><span class=\"pt8tzk-0 llJALx title dynamic-sizing\">lukket avdeling</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle6\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle6&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Utmelding i protest mot Listhaug-kurs\" href=\"https://www.dagbladet.no/nyheter/utmelding-i-protest-mot-listhaug-kurs/73732247\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Utmelding i protest mot Listhaug-kurs\" alt=\"Image: Utmelding i protest mot Listhaug-kurs\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73717372&amp;panoy=0&amp;panox=6.9105691056911&amp;panow=88.617886178862&amp;panoh=45.398773006135&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 ckFdEF title dynamic-sizing\">Utmelding i protest</span><span class=\"pt8tzk-0 HdRfg title dynamic-sizing\">mot Listhaug-kurs</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fant død ørn ved vindkraftverk\" href=\"https://www.dagbladet.no/nyheter/fant-dod-orn-ved-vindkraftverk/73718619\"><figure class=\"sc-1an7vu1-0 GhbEw\"><picture><img data-defer=\"view\" title=\"Image: Fant død ørn ved vindkraftverk\" alt=\"Image: Fant død ørn ved vindkraftverk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73723250&amp;panow=100&amp;panoh=25.357142857143&amp;panoy=26.785714285714&amp;panox=0&amp;heighty=16.176470588235&amp;heightx=5.9602649006623&amp;heightw=59.602649006623&amp;heighth=72.058823529412&amp;width=402&amp;height=295\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fkQbne title dynamic-sizing\">Fant død ørn ved</span><span class=\"pt8tzk-0 cgtUoG title dynamic-sizing\">vindkraftverk</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard8&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Trend-ølet: - Skikkelig vellykket!\" href=\"https://www.dagbladet.no/mat/trend-olet---skikkelig-vellykket/73719841\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Trend-ølet: - Skikkelig vellykket!\" alt=\"Image: Trend-ølet: - Skikkelig vellykket!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73733883&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 hWUOar title dynamic-sizing\">Trend-ølet:</span><span class=\"pt8tzk-0 ckFdEF title dynamic-sizing\">- Skikkelig</span><span class=\"pt8tzk-0 cnmBLP title dynamic-sizing\">vellykket!</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=\"Sjokkerer på date\" href=\"https://www.dagbladet.no/video/sjokkerer-pa-date/b4VVNQM7\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Sjokkerer på date\" alt=\"Image: Sjokkerer på date\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/b4VVNQM7-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cnmBLP title dynamic-sizing\">Sjokkerer</span><span class=\"pt8tzk-0 kgxnuC title dynamic-sizing\">på date</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slapp sterk musikkvideo: - Viktig\" href=\"https://www.dagbladet.no/video/slapp-sterk-musikkvideo-viktig/zRv1gP4A\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Slapp sterk musikkvideo: - Viktig\" alt=\"Image: Slapp sterk musikkvideo: - Viktig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/zRv1gP4A-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kzZypK title dynamic-sizing\">Slapp sterk</span><span class=\"pt8tzk-0 eRvGXV title dynamic-sizing\">musikkvideo: - Viktig</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=\"Sportsbil-drømmen under 300 000,-\" href=\"https://www.dagbladet.no/tema/seks-sportsbiler-under-300-000/73619874\"><figure class=\"sc-1an7vu1-0 brVaep\"><picture><img data-defer=\"view\" title=\"Image: Sportsbil-drømmen under 300 000,-\" alt=\"Image: Sportsbil-drømmen under 300 000,-\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73620383&amp;panoy=35.294117647059&amp;panox=16.918429003021&amp;panow=64.04833836858&amp;panoh=38.502673796791&amp;heightw=35.114503816794&amp;heighth=100&amp;heighty=0&amp;heightx=40.839694656489&amp;width=320&amp;height=176\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fEoqYx title dynamic-sizing\">Sportsbil-drømmen</span><span class=\"pt8tzk-0 eAJKef title dynamic-sizing\">under 300 000,-</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle7\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle7&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Angriper OL-kravet\" href=\"https://www.dagbladet.no/sport/angriper-ol-kravet/73732804\"><figure class=\"sc-1an7vu1-0 iSCaxr\"><picture><img data-defer=\"view\" title=\"Image: Angriper OL-kravet\" alt=\"Image: Angriper OL-kravet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73732823&amp;panow=100&amp;panoh=50&amp;panoy=21.12676056338&amp;panox=0&amp;heighty=0&amp;heightx=29.032258064516&amp;heightw=41.47465437788&amp;heighth=100&amp;width=485&amp;height=371\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 byeaVq title dynamic-sizing\">Angriper</span><span class=\"pt8tzk-0 FjFyP title dynamic-sizing\">OL-kravet</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Den nye «Olsenbanden» avslørt\" href=\"https://www.dagbladet.no/kultur/den-nye-olsenbanden-avslort/73727334\"><figure class=\"sc-1an7vu1-0 YaeJb\"><picture><img data-defer=\"view\" title=\"Image: Den nye «Olsenbanden» avslørt\" alt=\"Image: Den nye «Olsenbanden» avslørt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73727463&amp;panox=0&amp;panow=100&amp;panoh=51.428571428571&amp;panoy=5.7142857142857&amp;heightx=22.972972972973&amp;heightw=40.540540540541&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 jItpJm title dynamic-sizing\">Den nye</span><span class=\"pt8tzk-0 gNnpId title dynamic-sizing\">«Olsenbanden»</span><span class=\"pt8tzk-0 syWhf title dynamic-sizing\">avslørt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kåring: Eliteseriens største talenter\" href=\"https://www.dagbladet.no/sport/karing-eliteseriens-storste-talenter/73515704\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Kåring: Eliteseriens største talenter\" alt=\"Image: Kåring: Eliteseriens største talenter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73560520&amp;panox=0&amp;panow=100&amp;panoh=22.653721682848&amp;panoy=10.355987055016&amp;heighth=38.858695652174&amp;heighty=11.684782608696&amp;heightx=35.390946502058&amp;heightw=36.213991769547&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fEoqYx title dynamic-sizing\">Kåring: Eliteseriens</span><span class=\"pt8tzk-0 llJALx title dynamic-sizing\">største talenter</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=\"Forstyrrer presidenten\" href=\"https://www.dagbladet.no/video/forstyrrer-presidenten/r82oyyxS\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Forstyrrer presidenten\" alt=\"Image: Forstyrrer presidenten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/r82oyyxS-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cJqdVa title dynamic-sizing\">Forstyrrer</span><span class=\"pt8tzk-0 kXXbDl title dynamic-sizing\">presidenten</span></h3></header></a></article></div></div><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard9\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard9&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fikk sparken etter melding\" href=\"https://www.dagbladet.no/sport/fikk-sparken-etter-melding/73730091\"><figure class=\"sc-1an7vu1-0 dquykX\"><picture><img data-defer=\"view\" title=\"Image: Fikk sparken etter melding\" alt=\"Image: Fikk sparken etter melding\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73730160&amp;panox=5.5084745762712&amp;panoy=4.0229885057471&amp;panow=88.983050847458&amp;panoh=40.804597701149&amp;heighty=4.5454545454545&amp;heightx=34.200743494424&amp;heightw=33.457249070632&amp;heighth=74.242424242424&amp;width=402&amp;height=319\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gNnpId title dynamic-sizing\">Fikk sparken</span><span class=\"pt8tzk-0 cgtUoG title dynamic-sizing\">etter melding</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Voldsvideoen ryster Danmark\" href=\"https://www.dagbladet.no/nyheter/voldsvideoen-ryster-danmark/73722660\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Voldsvideoen ryster Danmark\" alt=\"Image: Voldsvideoen ryster Danmark\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73723274&amp;panow=100&amp;panoh=60.169491525424&amp;panoy=16.101694915254&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 eOoZPI title dynamic-sizing\">Voldsvideoen</span><span class=\"pt8tzk-0 iDNnFU title dynamic-sizing\">ryster Danmark</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=\"Her får bjørnen nok\" href=\"https://www.dagbladet.no/video/her-far-bjornen-nok/ASnIgjKR\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Her får bjørnen nok\" alt=\"Image: Her får bjørnen nok\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/ASnIgjKR-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 eTyBWU title dynamic-sizing\">Her får</span><span class=\"pt8tzk-0 kXXbDl title dynamic-sizing\">bjørnen nok</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=\"Åpner opp om bodybuildingens skyggesider\" href=\"https://www.dagbladet.no/nyheter/apner-opp-om-bodybuilder-miljoets-skyggesider/73630447\"><figure class=\"sc-1an7vu1-0 dSBzgi\"><picture><img data-defer=\"view\" title=\"Image: Åpner opp om bodybuildingens skyggesider\" alt=\"Image: Åpner opp om bodybuildingens skyggesider\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73644644&amp;panoy=28.373702422145&amp;panox=0&amp;panow=100&amp;panoh=24.221453287197&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=171\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 clKRtz title dynamic-sizing\">Åpner opp om</span><span class=\"pt8tzk-0 eWNmnq title dynamic-sizing\">bodybuildingens</span><span class=\"pt8tzk-0 bPaEDz title dynamic-sizing\">skyggesider</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle8&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Rasende: - Fratatt ytringsfriheten\" href=\"https://www.dagbladet.no/nyheter/rasende---fratatt-ytringsfriheten/73729729\"><figure class=\"sc-1an7vu1-0 eXdDG\"><picture><img data-defer=\"view\" title=\"Image: Rasende: - Fratatt ytringsfriheten\" alt=\"Image: Rasende: - Fratatt ytringsfriheten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73729732&amp;panoy=2.1276595744681&amp;panox=0&amp;panow=100&amp;panoh=51.063829787234&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gNnpId title dynamic-sizing\">Rasende: - Fratatt</span><span class=\"pt8tzk-0 bvyTBk title dynamic-sizing\">ytringsfriheten</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Svært pinlig for Norge\" href=\"https://www.dagbladet.no/nyheter/svaert-pinlig-for-norge/73731793\"><figure class=\"sc-1an7vu1-0 hJjTcc\"><picture><img data-defer=\"view\" title=\"Image: - Svært pinlig for Norge\" alt=\"Image: - Svært pinlig for Norge\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73731830&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=278\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 ckFdEF title dynamic-sizing\">- Svært pinlig</span><span class=\"pt8tzk-0 PHQVD title dynamic-sizing\">for Norge</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard10\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard10&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Iskrem-nyheter: - Helt magisk!\" href=\"https://www.dagbladet.no/mat/iskrem-nyheter---helt-magisk/73646202\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Iskrem-nyheter: - Helt magisk!\" alt=\"Image: Iskrem-nyheter: - Helt magisk!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73647751&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bYhFDa title dynamic-sizing\">Iskrem-nyheter:</span><span class=\"pt8tzk-0 clKRtz title dynamic-sizing\">- Helt magisk!</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=\"- Pass på hva du sier \" href=\"https://www.dagbladet.no/video/-pass-pa-hva-du-sier-/IgfxXjY8\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: - Pass på hva du sier \" alt=\"Image: - Pass på hva du sier \" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/IgfxXjY8-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kmPMzO title dynamic-sizing\">- Pass på</span><span class=\"pt8tzk-0 hWUOar title dynamic-sizing\">hva du sier </span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Forbløffende bilder\" href=\"https://www.dagbladet.no/video/forbloffende-bilder/HAMYxgHl\"><figure class=\"sc-1an7vu1-0 evVrtM\"><picture><img data-defer=\"view\" title=\"Image: Forbløffende bilder\" alt=\"Image: Forbløffende bilder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/HAMYxgHl-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dGLeEg title dynamic-sizing\">Forbløffende bilder</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Studie: Effekten av corona-vaksinen\" href=\"https://www.dagbladet.no/tema/ny-studie-effekten-av-corona-vaksinen/73578834\"><figure class=\"sc-1an7vu1-0 dSBzgi\"><picture><img data-defer=\"view\" title=\"Image: Studie: Effekten av corona-vaksinen\" alt=\"Image: Studie: Effekten av corona-vaksinen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73579133&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=41.7004048583&amp;heightw=38.056680161943&amp;heighth=100&amp;width=320&amp;height=171\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bYhFDa title dynamic-sizing\">Studie: Effekten</span><span class=\"pt8tzk-0 fEoqYx title dynamic-sizing\">av corona-vaksinen</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle9&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard11&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Problemer? Mannen sitter med nøkkelen\" href=\"https://www.dagbladet.no/tema/lever-du-i-et-rollemonster/73542890\"><figure class=\"sc-1an7vu1-0 cqZIja\"><picture><img data-defer=\"view\" title=\"Image: Problemer? Mannen sitter med nøkkelen\" alt=\"Image: Problemer? Mannen sitter med nøkkelen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73548918&amp;panoy=24.285714285714&amp;panox=0&amp;panow=100&amp;panoh=33.809523809524&amp;heighty=24.576271186441&amp;heightw=38.135593220339&amp;heighth=62.28813559322&amp;heightx=47.033898305085&amp;width=320&amp;height=170\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 SmgoK title dynamic-sizing\">Problemer? Mannen</span><span class=\"pt8tzk-0 fEoqYx title dynamic-sizing\">sitter med nøkkelen</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=\"Birks video delt av Snoop Dogg\" href=\"https://www.dagbladet.no/video/birks-video-delt-av-snoop-dogg/Unl2XggI\"><figure class=\"sc-1an7vu1-0 cqZIja\"><picture><img data-defer=\"view\" title=\"Image: Birks video delt av Snoop Dogg\" alt=\"Image: Birks video delt av Snoop Dogg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Unl2XggI-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 llJALx title dynamic-sizing\">Birks video delt</span><span class=\"pt8tzk-0 htNVWC title dynamic-sizing\">av Snoop Dogg</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Et under\" href=\"https://www.dagbladet.no/video/-et-under/8zRUTbXC\"><figure class=\"sc-1an7vu1-0 kIQEL\"><picture><img data-defer=\"view\" title=\"Image: - Et under\" alt=\"Image: - Et under\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/8zRUTbXC-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cJqdVa title dynamic-sizing\">- Et under</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=\"93 polnyheter: - Meget god\" href=\"https://www.dagbladet.no/tema/polslipp-de-beste-sommernyhetene/73723023\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: 93 polnyheter: - Meget god\" alt=\"Image: 93 polnyheter: - Meget god\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73725453&amp;panow=99.530516431925&amp;panoy=11.111111111111&amp;panox=0&amp;panoh=88.888888888889&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fmKQUI title dynamic-sizing\">93 polnyheter:</span><span class=\"pt8tzk-0 bPaEDz title dynamic-sizing\">- Meget god</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle10&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><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=\"Raser når drona kommer\" href=\"https://www.dagbladet.no/video/raser-nar-drona-kommer/KgDIOl5P\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Raser når drona kommer\" alt=\"Image: Raser når drona kommer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/KgDIOl5P-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bCpqdI title dynamic-sizing\">Raser når</span><span class=\"pt8tzk-0 fmKQUI title dynamic-sizing\">drona kommer</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=\"Test av vaffeljern: - Egen liga!\" href=\"https://www.dagbladet.no/mat/test-av-vaffeljern--en-egen-liga/73559490\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Test av vaffeljern: - Egen liga!\" alt=\"Image: Test av vaffeljern: - Egen liga!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73560539&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bwkOUE title dynamic-sizing\">Test av vaffeljern:</span><span class=\"pt8tzk-0 kzZypK title dynamic-sizing\">- Egen liga!</span></h3></header></a></article></div></div><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard12&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skulle bare fly dronen\" href=\"https://www.dagbladet.no/video/skulle-bare-fly-dronen/wvLy7ORx\"><figure class=\"sc-1an7vu1-0 exnSmk\"><picture><img data-defer=\"view\" title=\"Image: Skulle bare fly dronen\" alt=\"Image: Skulle bare fly dronen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/wvLy7ORx-720.jpg\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kzZypK title dynamic-sizing\">Skulle bare</span><span class=\"pt8tzk-0 gNnpId title dynamic-sizing\">fly dronen</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=\"Innrømmer: - Sa ting for oppmerksomhet\" href=\"https://www.dagbladet.no/tema/innrommer--sa-ting-for-oppmerksomhet/73642702\"><figure class=\"sc-1an7vu1-0 fjXeVU\"><picture><img data-defer=\"view\" title=\"Image: Innrømmer: - Sa ting for oppmerksomhet\" alt=\"Image: Innrømmer: - Sa ting for oppmerksomhet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73643334&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=22.077922077922&amp;heightx=28.654970760234&amp;heightw=26.315789473684&amp;heighth=64.069264069264&amp;width=320&amp;height=222\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bFmwRb title dynamic-sizing\">Innrømmer: - Sa ting</span><span class=\"pt8tzk-0 fEoqYx title dynamic-sizing\">for oppmerksomhet</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" 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-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle11&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div>"]
Last ned appen vår
Vi bryr oss om ditt personvern
dagbladet er en del av Aller Media, som er ansvarlig for dine data. Vi bruker dataene til å forbedre og tilpasse tjenestene, tilbudene og annonsene våre.