["<style data-styled=\"true\" data-styled-version=\"5.3.0\">.dhguxo.dhguxo.dhguxo.dhguxo{height:0;padding-bottom:50%;}/*!sc*/ .crBzcL.crBzcL.crBzcL.crBzcL{height:0;padding-bottom:49.89%;}/*!sc*/ .fvUTJz.fvUTJz.fvUTJz.fvUTJz{height:0;padding-bottom:50.1%;}/*!sc*/ .ierNx.ierNx.ierNx.ierNx{height:0;padding-bottom:55.46%;}/*!sc*/ .fmcTzS.fmcTzS.fmcTzS.fmcTzS{height:0;padding-bottom:53.43%;}/*!sc*/ .byyxXq.byyxXq.byyxXq.byyxXq{height:0;padding-bottom:49.91%;}/*!sc*/ .hKThXi.hKThXi.hKThXi.hKThXi{height:0;padding-bottom:119.15%;}/*!sc*/ .dwgdxu.dwgdxu.dwgdxu.dwgdxu{height:0;padding-bottom:75.12%;}/*!sc*/ .feaYkY.feaYkY.feaYkY.feaYkY{height:0;padding-bottom:51.87%;}/*!sc*/ .iGtuSh.iGtuSh.iGtuSh.iGtuSh{height:0;padding-bottom:54.43%;}/*!sc*/ .iLAavx.iLAavx.iLAavx.iLAavx{height:0;padding-bottom:53.48%;}/*!sc*/ .fzmxfG.fzmxfG.fzmxfG.fzmxfG{height:0;padding-bottom:54.37%;}/*!sc*/ .ksvZEE.ksvZEE.ksvZEE.ksvZEE{height:0;padding-bottom:57.5%;}/*!sc*/ .dgCfTN.dgCfTN.dgCfTN.dgCfTN{height:0;padding-bottom:78.14%;}/*!sc*/ .khrZnR.khrZnR.khrZnR.khrZnR{height:0;padding-bottom:53.19%;}/*!sc*/ .dKBcCK.dKBcCK.dKBcCK.dKBcCK{height:0;padding-bottom:53.12%;}/*!sc*/ .iALTIW.iALTIW.iALTIW.iALTIW{height:0;padding-bottom:111.19%;}/*!sc*/ .hfrPJh.hfrPJh.hfrPJh.hfrPJh{height:0;padding-bottom:53.73%;}/*!sc*/ .cXgSoO.cXgSoO.cXgSoO.cXgSoO{height:0;padding-bottom:62.5%;}/*!sc*/ .jxGDqV.jxGDqV.jxGDqV.jxGDqV{height:0;padding-bottom:52.81%;}/*!sc*/ .gWkPlf.gWkPlf.gWkPlf.gWkPlf{height:0;padding-bottom:88.55%;}/*!sc*/ .hWJZyt.hWJZyt.hWJZyt.hWJZyt{height:0;padding-bottom:117.41%;}/*!sc*/ .gkNcOt.gkNcOt.gkNcOt.gkNcOt{height:0;padding-bottom:58.96%;}/*!sc*/ .cHdpby.cHdpby.cHdpby.cHdpby{height:0;padding-bottom:87.31%;}/*!sc*/ .jFciZD.jFciZD.jFciZD.jFciZD{height:0;padding-bottom:78.43%;}/*!sc*/ .kCxZsK.kCxZsK.kCxZsK.kCxZsK{height:0;padding-bottom:68.65%;}/*!sc*/ .iCFVAH.iCFVAH.iCFVAH.iCFVAH{height:0;padding-bottom:52.78%;}/*!sc*/ .lkDdqF.lkDdqF.lkDdqF.lkDdqF{height:0;padding-bottom:59.2%;}/*!sc*/ .IPSiP.IPSiP.IPSiP.IPSiP{height:0;padding-bottom:108.45%;}/*!sc*/ .iJSWUD.iJSWUD.iJSWUD.iJSWUD{height:0;padding-bottom:56.25%;}/*!sc*/ .dZCBlL.dZCBlL.dZCBlL.dZCBlL{height:0;padding-bottom:69.69%;}/*!sc*/ .jrmSqJ.jrmSqJ.jrmSqJ.jrmSqJ{height:0;padding-bottom:114.17%;}/*!sc*/ .fxOLsM.fxOLsM.fxOLsM.fxOLsM{height:0;padding-bottom:64.94%;}/*!sc*/ .clIACb.clIACb.clIACb.clIACb{height:0;padding-bottom:57.46%;}/*!sc*/ .HmzvL.HmzvL.HmzvL.HmzvL{height:0;padding-bottom:60%;}/*!sc*/ .bfZJk.bfZJk.bfZJk.bfZJk{height:0;padding-bottom:61.44%;}/*!sc*/ .cRpTTR.cRpTTR.cRpTTR.cRpTTR{height:0;padding-bottom:84.57%;}/*!sc*/ .ljMRWg.ljMRWg.ljMRWg.ljMRWg{height:0;padding-bottom:66.25%;}/*!sc*/ .cYyUrL.cYyUrL.cYyUrL.cYyUrL{height:0;padding-bottom:53.79%;}/*!sc*/ .bNCpt.bNCpt.bNCpt.bNCpt{height:0;padding-bottom:55%;}/*!sc*/ .krISuO.krISuO.krISuO.krISuO{height:0;padding-bottom:68.43%;}/*!sc*/ data-styled.g176[id=\"sc-1an7vu1-0\"]{content:\"dhguxo,crBzcL,fvUTJz,ierNx,fmcTzS,byyxXq,hKThXi,dwgdxu,feaYkY,iGtuSh,iLAavx,fzmxfG,ksvZEE,dgCfTN,khrZnR,dKBcCK,iALTIW,hfrPJh,cXgSoO,jxGDqV,gWkPlf,hWJZyt,gkNcOt,cHdpby,jFciZD,kCxZsK,iCFVAH,lkDdqF,IPSiP,iJSWUD,dZCBlL,jrmSqJ,fxOLsM,clIACb,HmzvL,bfZJk,cRpTTR,ljMRWg,cYyUrL,bNCpt,krISuO,\"}/*!sc*/ .kCJKgB.kCJKgB.kCJKgB.kCJKgB{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kCJKgB.kCJKgB.kCJKgB.kCJKgB{font-size:1.7em!important;}}/*!sc*/ .jbzSci.jbzSci.jbzSci.jbzSci{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.jbzSci.jbzSci.jbzSci.jbzSci{font-size:1.3em!important;}}/*!sc*/ .dPJQg.dPJQg.dPJQg.dPJQg{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dPJQg.dPJQg.dPJQg.dPJQg{font-size:1.5em!important;}}/*!sc*/ .jNjUxV.jNjUxV.jNjUxV.jNjUxV{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jNjUxV.jNjUxV.jNjUxV.jNjUxV{font-size:0.9em!important;}}/*!sc*/ .jHdOmf.jHdOmf.jHdOmf.jHdOmf{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jHdOmf.jHdOmf.jHdOmf.jHdOmf{font-size:1.8em!important;}}/*!sc*/ .emKRhk.emKRhk.emKRhk.emKRhk{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.emKRhk.emKRhk.emKRhk.emKRhk{font-size:2em!important;}}/*!sc*/ .iNoFyN.iNoFyN.iNoFyN.iNoFyN{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.iNoFyN.iNoFyN.iNoFyN.iNoFyN{font-size:1.8em!important;}}/*!sc*/ .jBrNzn.jBrNzn.jBrNzn.jBrNzn{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jBrNzn.jBrNzn.jBrNzn.jBrNzn{font-size:1.9em!important;}}/*!sc*/ .bbKwji.bbKwji.bbKwji.bbKwji{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bbKwji.bbKwji.bbKwji.bbKwji{font-size:2.2em!important;}}/*!sc*/ .fdhepR.fdhepR.fdhepR.fdhepR{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.fdhepR.fdhepR.fdhepR.fdhepR{font-size:2.1em!important;}}/*!sc*/ .HUobe.HUobe.HUobe.HUobe{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.HUobe.HUobe.HUobe.HUobe{font-size:1.4em!important;}}/*!sc*/ .FGTZX.FGTZX.FGTZX.FGTZX{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.FGTZX.FGTZX.FGTZX.FGTZX{font-size:2.2em!important;}}/*!sc*/ .lngSfY.lngSfY.lngSfY.lngSfY{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.lngSfY.lngSfY.lngSfY.lngSfY{font-size:0.8em!important;}}/*!sc*/ .cyyIav.cyyIav.cyyIav.cyyIav{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.cyyIav.cyyIav.cyyIav.cyyIav{font-size:0.9em!important;}}/*!sc*/ .hOtlMY.hOtlMY.hOtlMY.hOtlMY{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.hOtlMY.hOtlMY.hOtlMY.hOtlMY{font-size:0.9em!important;}}/*!sc*/ .fCeQCp.fCeQCp.fCeQCp.fCeQCp{font-size:9.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.fCeQCp.fCeQCp.fCeQCp.fCeQCp{font-size:3.5em!important;}}/*!sc*/ .gyvhMP.gyvhMP.gyvhMP.gyvhMP{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gyvhMP.gyvhMP.gyvhMP.gyvhMP{font-size:1.3em!important;}}/*!sc*/ .bJaUWh.bJaUWh.bJaUWh.bJaUWh{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bJaUWh.bJaUWh.bJaUWh.bJaUWh{font-size:1.4em!important;}}/*!sc*/ .lmuWME.lmuWME.lmuWME.lmuWME{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.lmuWME.lmuWME.lmuWME.lmuWME{font-size:1.8em!important;}}/*!sc*/ .iJqVoj.iJqVoj.iJqVoj.iJqVoj{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.iJqVoj.iJqVoj.iJqVoj.iJqVoj{font-size:0.8em!important;}}/*!sc*/ .Kvzvk.Kvzvk.Kvzvk.Kvzvk{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.Kvzvk.Kvzvk.Kvzvk.Kvzvk{font-size:1.2em!important;}}/*!sc*/ .kJijAe.kJijAe.kJijAe.kJijAe{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kJijAe.kJijAe.kJijAe.kJijAe{font-size:0.7em!important;}}/*!sc*/ .iBMQzI.iBMQzI.iBMQzI.iBMQzI{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iBMQzI.iBMQzI.iBMQzI.iBMQzI{font-size:0.9em!important;}}/*!sc*/ .bDhNI.bDhNI.bDhNI.bDhNI{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bDhNI.bDhNI.bDhNI.bDhNI{font-size:1.3em!important;}}/*!sc*/ .bkQxHy.bkQxHy.bkQxHy.bkQxHy{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bkQxHy.bkQxHy.bkQxHy.bkQxHy{font-size:1.5em!important;}}/*!sc*/ .iOqgmm.iOqgmm.iOqgmm.iOqgmm{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iOqgmm.iOqgmm.iOqgmm.iOqgmm{font-size:1.6em!important;}}/*!sc*/ .bMVNYJ.bMVNYJ.bMVNYJ.bMVNYJ{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bMVNYJ.bMVNYJ.bMVNYJ.bMVNYJ{font-size:1.4em!important;}}/*!sc*/ .jXDONK.jXDONK.jXDONK.jXDONK{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jXDONK.jXDONK.jXDONK.jXDONK{font-size:1.2em!important;}}/*!sc*/ .fmYcXa.fmYcXa.fmYcXa.fmYcXa{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.fmYcXa.fmYcXa.fmYcXa.fmYcXa{font-size:0.5em!important;}}/*!sc*/ .fXHPND.fXHPND.fXHPND.fXHPND{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.fXHPND.fXHPND.fXHPND.fXHPND{font-size:1.1em!important;}}/*!sc*/ .khwVQb.khwVQb.khwVQb.khwVQb{font-size:8.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.khwVQb.khwVQb.khwVQb.khwVQb{font-size:2.9em!important;}}/*!sc*/ .kwPZyP.kwPZyP.kwPZyP.kwPZyP{font-size:7.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.kwPZyP.kwPZyP.kwPZyP.kwPZyP{font-size:2.5em!important;}}/*!sc*/ .clHgld.clHgld.clHgld.clHgld{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.clHgld.clHgld.clHgld.clHgld{font-size:1.3em!important;}}/*!sc*/ .lNXGQ.lNXGQ.lNXGQ.lNXGQ{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.lNXGQ.lNXGQ.lNXGQ.lNXGQ{font-size:1.1em!important;}}/*!sc*/ .hPTmgJ.hPTmgJ.hPTmgJ.hPTmgJ{font-size:8.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.hPTmgJ.hPTmgJ.hPTmgJ.hPTmgJ{font-size:2.8em!important;}}/*!sc*/ .cGVeEg.cGVeEg.cGVeEg.cGVeEg{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cGVeEg.cGVeEg.cGVeEg.cGVeEg{font-size:1.6em!important;}}/*!sc*/ .foNJuB.foNJuB.foNJuB.foNJuB{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.foNJuB.foNJuB.foNJuB.foNJuB{font-size:1.5em!important;}}/*!sc*/ .zHZpy.zHZpy.zHZpy.zHZpy{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.zHZpy.zHZpy.zHZpy.zHZpy{font-size:0.9em!important;}}/*!sc*/ .drkMls.drkMls.drkMls.drkMls{font-size:10.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.drkMls.drkMls.drkMls.drkMls{font-size:3.7em!important;}}/*!sc*/ .kClav.kClav.kClav.kClav{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kClav.kClav.kClav.kClav{font-size:1.7em!important;}}/*!sc*/ .csMjjt.csMjjt.csMjjt.csMjjt{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.csMjjt.csMjjt.csMjjt.csMjjt{font-size:1.4em!important;}}/*!sc*/ .fMjDDP.fMjDDP.fMjDDP.fMjDDP{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.fMjDDP.fMjDDP.fMjDDP.fMjDDP{font-size:1.3em!important;}}/*!sc*/ .bKgILb.bKgILb.bKgILb.bKgILb{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bKgILb.bKgILb.bKgILb.bKgILb{font-size:1em!important;}}/*!sc*/ .dslBJt.dslBJt.dslBJt.dslBJt{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dslBJt.dslBJt.dslBJt.dslBJt{font-size:1.1em!important;}}/*!sc*/ .gYwDTf.gYwDTf.gYwDTf.gYwDTf{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.gYwDTf.gYwDTf.gYwDTf.gYwDTf{font-size:0.7em!important;}}/*!sc*/ .gufltt.gufltt.gufltt.gufltt{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.gufltt.gufltt.gufltt.gufltt{font-size:1.7em!important;}}/*!sc*/ .gkvAMf.gkvAMf.gkvAMf.gkvAMf{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.gkvAMf.gkvAMf.gkvAMf.gkvAMf{font-size:1.7em!important;}}/*!sc*/ .dJUPJq.dJUPJq.dJUPJq.dJUPJq{font-size:9.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dJUPJq.dJUPJq.dJUPJq.dJUPJq{font-size:3.7em!important;}}/*!sc*/ .ktOFii.ktOFii.ktOFii.ktOFii{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.ktOFii.ktOFii.ktOFii.ktOFii{font-size:2.7em!important;}}/*!sc*/ .dMquZC.dMquZC.dMquZC.dMquZC{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.dMquZC.dMquZC.dMquZC.dMquZC{font-size:1.1em!important;}}/*!sc*/ .gSjNoe.gSjNoe.gSjNoe.gSjNoe{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.gSjNoe.gSjNoe.gSjNoe.gSjNoe{font-size:1em!important;}}/*!sc*/ .eEyqYx.eEyqYx.eEyqYx.eEyqYx{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.eEyqYx.eEyqYx.eEyqYx.eEyqYx{font-size:1.6em!important;}}/*!sc*/ .fduMUN.fduMUN.fduMUN.fduMUN{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.fduMUN.fduMUN.fduMUN.fduMUN{font-size:1.7em!important;}}/*!sc*/ .gUvYku.gUvYku.gUvYku.gUvYku{font-size:7.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.gUvYku.gUvYku.gUvYku.gUvYku{font-size:2.8em!important;}}/*!sc*/ .bkotuw.bkotuw.bkotuw.bkotuw{font-size:6.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bkotuw.bkotuw.bkotuw.bkotuw{font-size:2.3em!important;}}/*!sc*/ .dHiqVh.dHiqVh.dHiqVh.dHiqVh{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dHiqVh.dHiqVh.dHiqVh.dHiqVh{font-size:1.9em!important;}}/*!sc*/ .VWhKg.VWhKg.VWhKg.VWhKg{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.VWhKg.VWhKg.VWhKg.VWhKg{font-size:1em!important;}}/*!sc*/ .kwfIKj.kwfIKj.kwfIKj.kwfIKj{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.kwfIKj.kwfIKj.kwfIKj.kwfIKj{font-size:2.3em!important;}}/*!sc*/ .jlskEK.jlskEK.jlskEK.jlskEK{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jlskEK.jlskEK.jlskEK.jlskEK{font-size:1.2em!important;}}/*!sc*/ .hBNdrH.hBNdrH.hBNdrH.hBNdrH{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.hBNdrH.hBNdrH.hBNdrH.hBNdrH{font-size:1.1em!important;}}/*!sc*/ .hPWSFu.hPWSFu.hPWSFu.hPWSFu{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.hPWSFu.hPWSFu.hPWSFu.hPWSFu{font-size:1.3em!important;}}/*!sc*/ .gdUHjZ.gdUHjZ.gdUHjZ.gdUHjZ{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.gdUHjZ.gdUHjZ.gdUHjZ.gdUHjZ{font-size:0.8em!important;}}/*!sc*/ .jzxvpJ.jzxvpJ.jzxvpJ.jzxvpJ{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jzxvpJ.jzxvpJ.jzxvpJ.jzxvpJ{font-size:1.2em!important;}}/*!sc*/ .jsUlRE.jsUlRE.jsUlRE.jsUlRE{font-size:10.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jsUlRE.jsUlRE.jsUlRE.jsUlRE{font-size:3.8em!important;}}/*!sc*/ .gKYxan.gKYxan.gKYxan.gKYxan{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.gKYxan.gKYxan.gKYxan.gKYxan{font-size:1.2em!important;}}/*!sc*/ .fjYhKA.fjYhKA.fjYhKA.fjYhKA{font-size:6.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.fjYhKA.fjYhKA.fjYhKA.fjYhKA{font-size:2.3em!important;}}/*!sc*/ .iSUFlZ.iSUFlZ.iSUFlZ.iSUFlZ{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iSUFlZ.iSUFlZ.iSUFlZ.iSUFlZ{font-size:2.4em!important;}}/*!sc*/ .kWQDJU.kWQDJU.kWQDJU.kWQDJU{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.kWQDJU.kWQDJU.kWQDJU.kWQDJU{font-size:1em!important;}}/*!sc*/ .dynFZO.dynFZO.dynFZO.dynFZO{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dynFZO.dynFZO.dynFZO.dynFZO{font-size:0.8em!important;}}/*!sc*/ .kLTsGD.kLTsGD.kLTsGD.kLTsGD{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.kLTsGD.kLTsGD.kLTsGD.kLTsGD{font-size:1.6em!important;}}/*!sc*/ .efOKKV.efOKKV.efOKKV.efOKKV{font-size:2.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.efOKKV.efOKKV.efOKKV.efOKKV{font-size:0.7em!important;}}/*!sc*/ .laaIGs.laaIGs.laaIGs.laaIGs{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.laaIGs.laaIGs.laaIGs.laaIGs{font-size:1.7em!important;}}/*!sc*/ .hVsjqQ.hVsjqQ.hVsjqQ.hVsjqQ{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.hVsjqQ.hVsjqQ.hVsjqQ.hVsjqQ{font-size:2.2em!important;}}/*!sc*/ .gFUAmj.gFUAmj.gFUAmj.gFUAmj{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.gFUAmj.gFUAmj.gFUAmj.gFUAmj{font-size:1.7em!important;}}/*!sc*/ .dBWvKD.dBWvKD.dBWvKD.dBWvKD{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dBWvKD.dBWvKD.dBWvKD.dBWvKD{font-size:1.4em!important;}}/*!sc*/ .ldAOMI.ldAOMI.ldAOMI.ldAOMI{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.ldAOMI.ldAOMI.ldAOMI.ldAOMI{font-size:1.4em!important;}}/*!sc*/ .dRiDot.dRiDot.dRiDot.dRiDot{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.dRiDot.dRiDot.dRiDot.dRiDot{font-size:1.2em!important;}}/*!sc*/ .kgUnLq.kgUnLq.kgUnLq.kgUnLq{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kgUnLq.kgUnLq.kgUnLq.kgUnLq{font-size:2em!important;}}/*!sc*/ .kiaerN.kiaerN.kiaerN.kiaerN{font-size:8.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kiaerN.kiaerN.kiaerN.kiaerN{font-size:3.1em!important;}}/*!sc*/ .bGSxIf.bGSxIf.bGSxIf.bGSxIf{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bGSxIf.bGSxIf.bGSxIf.bGSxIf{font-size:2.6em!important;}}/*!sc*/ .giZETU.giZETU.giZETU.giZETU{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.giZETU.giZETU.giZETU.giZETU{font-size:1.9em!important;}}/*!sc*/ .cilyqE.cilyqE.cilyqE.cilyqE{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cilyqE.cilyqE.cilyqE.cilyqE{font-size:0.7em!important;}}/*!sc*/ .OMVyn.OMVyn.OMVyn.OMVyn{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.OMVyn.OMVyn.OMVyn.OMVyn{font-size:1.5em!important;}}/*!sc*/ .fsCidJ.fsCidJ.fsCidJ.fsCidJ{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.fsCidJ.fsCidJ.fsCidJ.fsCidJ{font-size:2.1em!important;}}/*!sc*/ .TWGab.TWGab.TWGab.TWGab{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.TWGab.TWGab.TWGab.TWGab{font-size:2em!important;}}/*!sc*/ data-styled.g177[id=\"pt8tzk-0\"]{content:\"kCJKgB,jbzSci,dPJQg,jNjUxV,jHdOmf,emKRhk,iNoFyN,jBrNzn,bbKwji,fdhepR,HUobe,FGTZX,lngSfY,cyyIav,hOtlMY,fCeQCp,gyvhMP,bJaUWh,lmuWME,iJqVoj,Kvzvk,kJijAe,iBMQzI,bDhNI,bkQxHy,iOqgmm,bMVNYJ,jXDONK,fmYcXa,fXHPND,khwVQb,kwPZyP,clHgld,lNXGQ,hPTmgJ,cGVeEg,foNJuB,zHZpy,drkMls,kClav,csMjjt,fMjDDP,bKgILb,dslBJt,gYwDTf,gufltt,gkvAMf,dJUPJq,ktOFii,dMquZC,gSjNoe,eEyqYx,fduMUN,gUvYku,bkotuw,dHiqVh,VWhKg,kwfIKj,jlskEK,hBNdrH,hPWSFu,gdUHjZ,jzxvpJ,jsUlRE,gKYxan,fjYhKA,iSUFlZ,kWQDJU,dynFZO,kLTsGD,efOKKV,laaIGs,hVsjqQ,gFUAmj,dBWvKD,ldAOMI,dRiDot,kgUnLq,kiaerN,bGSxIf,giZETU,cilyqE,OMVyn,fsCidJ,TWGab,\"}/*!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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Plutselig smeller det\" href=\"https://www.dagbladet.no/video/plutselig-smeller-det/ak4eX6ce\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Plutselig smeller det\" alt=\"Image: Plutselig smeller det\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/ak4eX6ce-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 kCJKgB title dynamic-sizing\">Plutselig</span><span class=\"pt8tzk-0 jbzSci title dynamic-sizing\">smeller det</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=\"Hadde 16 kroner på konto\" href=\"https://www.dagbladet.no/kultur/hadde-16-kroner-pa-konto/74379725\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Hadde 16 kroner på konto\" alt=\"Image: Hadde 16 kroner på konto\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74405032&amp;panox=43.419267299864&amp;panow=29.579375848033&amp;panoh=15.195071868583&amp;panoy=31.416837782341&amp;heighty=28.091603053435&amp;heightx=52.610030706244&amp;heightw=9.6212896622313&amp;heighth=23.358778625954&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 dPJQg title dynamic-sizing\">Hadde 16</span><span class=\"pt8tzk-0 jNjUxV title dynamic-sizing\">kroner på konto</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=\"Frykter store oppsigelser\" href=\"https://www.dagbladet.no/sport/frykter-store-oppsigelser/74468934\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Frykter store oppsigelser\" alt=\"Image: Frykter store oppsigelser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74491687&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 jHdOmf title dynamic-sizing\">Frykter store</span><span class=\"pt8tzk-0 emKRhk title dynamic-sizing\">oppsigelser</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=\"Måtte amme ektemannen\" href=\"https://www.dagbladet.no/kjendis/matte-amme-ektemannen/74469534\"><figure class=\"sc-1an7vu1-0 fvUTJz\"><picture><img data-defer=\"view\" title=\"Image: Måtte amme ektemannen\" alt=\"Image: Måtte amme ektemannen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74469581&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=243\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 iNoFyN title dynamic-sizing\">Måtte amme</span><span class=\"pt8tzk-0 jBrNzn title dynamic-sizing\">ektemannen</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=\"Smittet for andre gang\" href=\"https://www.dagbladet.no/kjendis/smittet-for-andre-gang/74491842\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Smittet for andre gang\" alt=\"Image: Smittet for andre gang\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74491848&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 bbKwji title dynamic-sizing\">Smittet for</span><span class=\"pt8tzk-0 fdhepR title dynamic-sizing\">andre gang</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=\"Weng satt alene på julaften\" href=\"https://www.dagbladet.no/sport/heidi-weng-satt-alene-pa-julaften/74484232\"><figure class=\"sc-1an7vu1-0 ierNx\"><picture><img data-defer=\"view\" title=\"Image: Weng satt alene på julaften\" alt=\"Image: Weng satt alene på julaften\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73883228&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=269\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 HUobe title dynamic-sizing\">Weng satt alene</span><span class=\"pt8tzk-0 FGTZX title dynamic-sizing\">på julaften</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=\"Proteindrikk-test: Disse er sunnest\" href=\"https://www.dagbladet.no/tema/proteindrikk-test-disse-er-sunnest/74413414\"><figure class=\"sc-1an7vu1-0 fmcTzS\"><picture><img data-defer=\"view\" title=\"Image: Proteindrikk-test: Disse er sunnest\" alt=\"Image: Proteindrikk-test: Disse er sunnest\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74468763&amp;panow=100&amp;panoh=67.889908256881&amp;panoy=29.357798165138&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&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 lngSfY title dynamic-sizing\">Proteindrikk-test:</span><span class=\"pt8tzk-0 cyyIav title dynamic-sizing\">Disse er sunnest</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=\"Overrasker alle med babynyhet\" href=\"https://www.dagbladet.no/video/overrasker-alle-med-babynyhet/jWCLCsMw\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Overrasker alle med babynyhet\" alt=\"Image: Overrasker alle med babynyhet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/jWCLCsMw-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 hOtlMY title dynamic-sizing\">Overrasker alle</span><span class=\"pt8tzk-0 jNjUxV title dynamic-sizing\">med babynyhet</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=\"- Fysisk mishandling\" href=\"https://www.dagbladet.no/kjendis/fysisk-mishandling/74491862\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: - Fysisk mishandling\" alt=\"Image: - Fysisk mishandling\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74491872&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 fCeQCp title dynamic-sizing\">- Fysisk</span><span class=\"pt8tzk-0 FGTZX title dynamic-sizing\">mishandling</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=\"- Stank av død\" href=\"https://www.dagbladet.no/nyheter/stank-av-dod/74487766\"><figure class=\"sc-1an7vu1-0 hKThXi\"><picture><img data-defer=\"view\" title=\"Image: - Stank av død\" alt=\"Image: - Stank av død\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74491108&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=479\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gyvhMP title dynamic-sizing\">- Stank av død</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=\"Skjebnekamp\" href=\"https://www.dagbladet.no/sport/skjebnekamp/74492175\"><figure class=\"sc-1an7vu1-0 dwgdxu\"><picture><img data-defer=\"view\" title=\"Image: Skjebnekamp\" alt=\"Image: Skjebnekamp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74492283&amp;panoy=27.142857142857&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;heightx=22.62443438914&amp;width=402&amp;height=302\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bJaUWh title dynamic-sizing\">Skjebnekamp</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=\"- Skremmende\" href=\"https://www.dagbladet.no/sport/skremmende/74485447\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: - Skremmende\" alt=\"Image: - Skremmende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=72363178&amp;panoy=15.862068965517&amp;panox=0&amp;panow=100&amp;panoh=48.965517241379&amp;heightx=27.699530516432&amp;heightw=42.253521126761&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 lmuWME title dynamic-sizing\">- Skremmende</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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kobler periodontitt til alvorlig sykdom\" href=\"https://www.dagbladet.no/tema/kobler-periodontitt-til-alvorlig-sykdom/74304029\"><figure class=\"sc-1an7vu1-0 feaYkY\"><picture><img data-defer=\"view\" title=\"Image: Kobler periodontitt til alvorlig sykdom\" alt=\"Image: Kobler periodontitt til alvorlig sykdom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74338228&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=320&amp;height=166\" 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 iJqVoj title dynamic-sizing\">Kobler periodontitt</span><span class=\"pt8tzk-0 lngSfY title dynamic-sizing\">til alvorlig sykdom</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nøkkeltriks: - Mange vet det ikke\" href=\"https://www.dagbladet.no/video/nokkeltriks-mange-vet-det-ikke/F3mEU5FD\"><figure class=\"sc-1an7vu1-0 feaYkY\"><picture><img data-defer=\"view\" title=\"Image: Nøkkeltriks: - Mange vet det ikke\" alt=\"Image: Nøkkeltriks: - Mange vet det ikke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/F3mEU5FD-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 Kvzvk title dynamic-sizing\">Nøkkeltriks:</span><span class=\"pt8tzk-0 kJijAe title dynamic-sizing\">- Mange vet det ikke</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=\"Kommer med lovnad til de som tjener under 750 000\" href=\"https://www.dagbladet.no/nyheter/kommer-med-lovnad-til-de-som-tjener-under-750-000/74483722\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Kommer med lovnad til de som tjener under 750 000\" alt=\"Image: Kommer med lovnad til de som tjener under 750 000\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74483757&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 iBMQzI title dynamic-sizing\">Kommer med lovnad til de</span><span class=\"pt8tzk-0 cyyIav title dynamic-sizing\">som tjener under 750 000</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=\"Refses etter dette\" href=\"https://www.dagbladet.no/kjendis/refses-etter-dette/74476535\"><figure class=\"sc-1an7vu1-0 iGtuSh\"><picture><img data-defer=\"view\" title=\"Image: Refses etter dette\" alt=\"Image: Refses etter dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74476568&amp;panox=11.382113821138&amp;panow=88.617886178862&amp;panoh=44.311377245509&amp;panoy=11.377245508982&amp;heighty=0&amp;heightx=37.777777777778&amp;heightw=41.777777777778&amp;heighth=100&amp;width=485&amp;height=264\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bDhNI title dynamic-sizing\">Refses etter dette</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=\"Avlyser konserter etter kreftdiagnose\" href=\"https://www.dagbladet.no/kjendis/avlyser-konserter-etter-kreftdiagnose/74487126\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Avlyser konserter etter kreftdiagnose\" alt=\"Image: Avlyser konserter etter kreftdiagnose\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74487144&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 bkQxHy title dynamic-sizing\">Avlyser konserter</span><span class=\"pt8tzk-0 bJaUWh title dynamic-sizing\">etter kreftdiagnose</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=\"Forlot drept sønn (8) med søskenflokken\" href=\"https://www.dagbladet.no/nyheter/forlot-drept-sonn-8-med-soskenflokken/74467005\"><figure class=\"sc-1an7vu1-0 iLAavx\"><picture><img data-defer=\"view\" title=\"Image: Forlot drept sønn (8) med søskenflokken\" alt=\"Image: Forlot drept sønn (8) med søskenflokken\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74451496&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=215\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 iOqgmm title dynamic-sizing\">Forlot drept</span><span class=\"pt8tzk-0 bMVNYJ title dynamic-sizing\">sønn (8) med</span><span class=\"pt8tzk-0 bDhNI title dynamic-sizing\">søskenflokken</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=\"Brødet som fjerner magefettet\" href=\"https://www.dagbladet.no/tema/brodet-som-fjerner-magefettet/74407750\"><figure class=\"sc-1an7vu1-0 fzmxfG\"><picture><img data-defer=\"view\" title=\"Image: Brødet som fjerner magefettet\" alt=\"Image: Brødet som fjerner magefettet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74411901&amp;panow=100&amp;panoh=51.034482758621&amp;panoy=0&amp;panox=0&amp;heightw=40.869565217391&amp;heighty=0&amp;heightx=50.434782608696&amp;heighth=100&amp;width=320&amp;height=174\" 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 gyvhMP title dynamic-sizing\">Brødet som</span><span class=\"pt8tzk-0 lngSfY title dynamic-sizing\">fjerner magefettet</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=\"Kjøttetende kjønnssykdom sprer seg\" href=\"https://www.dagbladet.no/video/kjottetende-kjonnssykdom-sprer-seg/cSesd2Kp\"><figure class=\"sc-1an7vu1-0 ksvZEE\"><picture><img data-defer=\"view\" title=\"Image: Kjøttetende kjønnssykdom sprer seg\" alt=\"Image: Kjøttetende kjønnssykdom sprer seg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/cSesd2Kp-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 jXDONK title dynamic-sizing\">Kjøttetende</span><span class=\"pt8tzk-0 fmYcXa title dynamic-sizing\">kjønnssykdom sprer seg</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=\"Se hvem som dukket opp\" href=\"https://www.dagbladet.no/video/se-hvem-som-dukket-opp/51w7v5rT\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Se hvem som dukket opp\" alt=\"Image: Se hvem som dukket opp\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/51w7v5rT-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 fXHPND title dynamic-sizing\">Se hvem som</span><span class=\"pt8tzk-0 jbzSci title dynamic-sizing\">dukket opp</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=\"- Må vel bytte sjef\" href=\"https://www.dagbladet.no/sport/ma-vel-bytte-sjef/74491692\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: - Må vel bytte sjef\" alt=\"Image: - Må vel bytte sjef\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74491712&amp;panoy=8.3333333333333&amp;panox=3.4188034188034&amp;panow=88.897792307692&amp;panoh=49.320023611111&amp;heightw=37.561533333333&amp;heighth=100.01426986301&amp;heightx=50.847457627119&amp;heighty=0.014269863013704&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 khwVQb title dynamic-sizing\">- Må vel</span><span class=\"pt8tzk-0 kwPZyP title dynamic-sizing\">bytte sjef</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=\"Skandalebilder fra gymsal lekket på nett\" href=\"https://www.dagbladet.no/nyheter/skandalebilder-fra-gymsal-lekket-pa-nett/74477093\"><figure class=\"sc-1an7vu1-0 dgCfTN\"><picture><img data-defer=\"view\" title=\"Image: Skandalebilder fra gymsal lekket på nett\" alt=\"Image: Skandalebilder fra gymsal lekket på nett\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74478099&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=67.741935483871&amp;heightw=32.258064516129&amp;heighth=100&amp;width=485&amp;height=379\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 clHgld title dynamic-sizing\">Skandalebilder fra</span><span class=\"pt8tzk-0 lNXGQ title dynamic-sizing\">gymsal lekket på nett</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=\"- Trener opptil 13 timer\" href=\"https://www.dagbladet.no/sport/trener-opptil-13-timer/74478236\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: - Trener opptil 13 timer\" alt=\"Image: - Trener opptil 13 timer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74485768&amp;panoh=50.714285714286&amp;panoy=7.8571428571429&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=39.366515837104&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 hPTmgJ title dynamic-sizing\">- Trener</span><span class=\"pt8tzk-0 cGVeEg title dynamic-sizing\">opptil 13 timer</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=\"Var Norges nye langrennsprinsesse. Så ble hun borte\" href=\"https://www.dagbladet.no/sport/var-norges-nye-langrennsprinsesse-sa-ble-hun-borte/74458676\"><figure class=\"sc-1an7vu1-0 khrZnR\"><picture><img data-defer=\"view\" title=\"Image: Var Norges nye langrennsprinsesse. Så ble hun borte\" alt=\"Image: Var Norges nye langrennsprinsesse. Så ble hun borte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74458723&amp;panow=100&amp;panoh=25.631768953069&amp;panoy=8.3032490974729&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=258\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 foNJuB title dynamic-sizing\">Var Norges nye</span><span class=\"pt8tzk-0 fXHPND title dynamic-sizing\">langrennsprinsesse.</span><span class=\"pt8tzk-0 HUobe title dynamic-sizing\">Så ble hun borte</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Peisvindu: Genialt rengjørings-tips\" href=\"https://www.dagbladet.no/video/peisvindu-genialt-rengjorings-tips/AMisiSWM\"><figure class=\"sc-1an7vu1-0 dKBcCK\"><picture><img data-defer=\"view\" title=\"Image: Peisvindu: Genialt rengjørings-tips\" alt=\"Image: Peisvindu: Genialt rengjørings-tips\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/AMisiSWM-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 lngSfY title dynamic-sizing\">Peisvindu: Genialt</span><span class=\"pt8tzk-0 zHZpy title dynamic-sizing\">rengjørings-tips</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=\"Tarmproblemer: Løsningen få vet om\" href=\"https://www.dagbladet.no/tema/tarmproblemer-losningen-fa-vet-om/74302707\"><figure class=\"sc-1an7vu1-0 dKBcCK\"><picture><img data-defer=\"view\" title=\"Image: Tarmproblemer: Løsningen få vet om\" alt=\"Image: Tarmproblemer: Løsningen få vet om\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74412956&amp;panoy=45.323741007194&amp;panox=0&amp;panow=100&amp;panoh=51.079136690647&amp;heightx=30.909090909091&amp;heightw=40.909090909091&amp;heighth=100&amp;heighty=0&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 zHZpy title dynamic-sizing\">Tarmproblemer:</span><span class=\"pt8tzk-0 kJijAe title dynamic-sizing\">Løsningen få vet om</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=\"Refses: - Ufattelig naivt\" href=\"https://www.dagbladet.no/nyheter/refses---ufattelig-naivt/74468253\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Refses: - Ufattelig naivt\" alt=\"Image: Refses: - Ufattelig naivt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74468894&amp;panow=100&amp;panoh=100&amp;panox=0&amp;panoy=0&amp;heighty=0.0077835616438261&amp;heightx=10.502283105023&amp;heightw=41.101079452055&amp;heighth=100.00778356164&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 drkMls title dynamic-sizing\">Refses:</span><span class=\"pt8tzk-0 kClav title dynamic-sizing\">- Ufattelig naivt</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=\"11-åring fikk corona - døde to dager seinere\" href=\"https://www.dagbladet.no/nyheter/11-aring-fikk-corona---dode-to-dager-seinere/74466238\"><figure class=\"sc-1an7vu1-0 iALTIW\"><picture><img data-defer=\"view\" title=\"Image: 11-åring fikk corona - døde to dager seinere\" alt=\"Image: 11-åring fikk corona - døde to dager seinere\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74466467&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=447\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 zHZpy title dynamic-sizing\">11-åring fikk corona</span><span class=\"pt8tzk-0 iJqVoj title dynamic-sizing\">- døde to dager seinere</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=\"Derfor vinner de «ingenting»\" href=\"https://www.dagbladet.no/kjendis/derfor-vinner-de-ingenting/74484585\"><figure class=\"sc-1an7vu1-0 hfrPJh\"><picture><img data-defer=\"view\" title=\"Image: Derfor vinner de «ingenting»\" alt=\"Image: Derfor vinner de «ingenting»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74486048&amp;panox=0&amp;panow=100&amp;panoh=51.079136690647&amp;panoy=2.8776978417266&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=216\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 csMjjt title dynamic-sizing\">Derfor vinner</span><span class=\"pt8tzk-0 fMjDDP title dynamic-sizing\">de «ingenting»</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=\"Årets råeste plate?\" href=\"https://www.dagbladet.no/kultur/arets-raeste-plate/74467341\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Årets råeste plate?\" alt=\"Image: Årets råeste plate?\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74467412&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=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"dice-wrap\"><svg class=\"dice\" width=\"100%\" height=\"100%\" viewBox=\"0 0 100 100\" preserveAspectRatio=\"none\"><rect class=\"face\" x=\"0\" y=\"0\" width=\"100\" height=\"100\"></rect><path class=\"face-shade\" d=\"M 0 0 L 100 0 L 0 100 z\"></path><circle class=\"pip\" cx=\"25\" cy=\"25\" r=\"10\"></circle><circle class=\"pip\" cx=\"25\" cy=\"50\" r=\"10\"></circle><circle class=\"pip\" cx=\"25\" cy=\"75\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"25\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"50\" r=\"10\"></circle><circle class=\"pip\" cx=\"75\" cy=\"75\" r=\"10\"></circle></svg></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 HUobe title dynamic-sizing\">Årets råeste plate?</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=\"Skilsmisse: Faresignalene du bør frykte\" href=\"https://www.dagbladet.no/tema/psykolog-grepene-som-forhindrer-skilsmisse/74370034\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Skilsmisse: Faresignalene du bør frykte\" alt=\"Image: Skilsmisse: Faresignalene du bør frykte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=72391759&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=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 gyvhMP title dynamic-sizing\">Skilsmisse:</span><span class=\"pt8tzk-0 bKgILb title dynamic-sizing\">Faresignalene</span><span class=\"pt8tzk-0 dslBJt title dynamic-sizing\">du bør frykte</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=\"McDonalds-ansatt avslører\" href=\"https://www.dagbladet.no/video/mcdonalds-ansatt-avslorer/fnLj5Rna\"><figure class=\"sc-1an7vu1-0 cXgSoO\"><picture><img data-defer=\"view\" title=\"Image: McDonalds-ansatt avslører\" alt=\"Image: McDonalds-ansatt avslører\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/fnLj5Rna-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 gYwDTf title dynamic-sizing\">McDonalds-ansatt</span><span class=\"pt8tzk-0 gufltt title dynamic-sizing\">avslører</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=\"Ikke tøm ut vannet\" href=\"https://www.dagbladet.no/video/ikke-tom-ut-vannet/uVm42TVw\"><figure class=\"sc-1an7vu1-0 jxGDqV\"><picture><img data-defer=\"view\" title=\"Image: Ikke tøm ut vannet\" alt=\"Image: Ikke tøm ut vannet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uVm42TVw-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 kClav title dynamic-sizing\">Ikke tøm</span><span class=\"pt8tzk-0 iOqgmm title dynamic-sizing\">ut vannet</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=\"Stunt vekker harme: - Usmakelighet\" href=\"https://www.dagbladet.no/kjendis/stunt-vekker-harme---usmakelighet/74476219\"><figure class=\"sc-1an7vu1-0 gWkPlf\"><picture><img data-defer=\"view\" title=\"Image: Stunt vekker harme: - Usmakelighet\" alt=\"Image: Stunt vekker harme: - Usmakelighet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74477841&amp;panow=100&amp;panoh=51.449275362319&amp;panox=0&amp;panoy=5.0724637681159&amp;heighty=0&amp;heightx=0&amp;heightw=40.358744394619&amp;heighth=100&amp;width=402&amp;height=356\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 zHZpy title dynamic-sizing\">Stunt vekker harme:</span><span class=\"pt8tzk-0 Kvzvk title dynamic-sizing\">- Usmakelighet</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=\"Håvet inn 36 mill.: - Bare dritt\" href=\"https://www.dagbladet.no/kjendis/havet-inn-36-mill---bare-dritt/74485173\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Håvet inn 36 mill.: - Bare dritt\" alt=\"Image: Håvet inn 36 mill.: - Bare dritt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74485384&amp;panoy=1.2738853503185&amp;panox=0&amp;panow=100&amp;panoh=45.222929936306&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bbKwji title dynamic-sizing\">Håvet inn 36</span><span class=\"pt8tzk-0 gkvAMf title dynamic-sizing\">mill.: - Bare dritt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7 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=\"Ville bli god på ski\" href=\"https://www.dagbladet.no/sport/kamp-pa-livet-los/74468831\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Ville bli god på ski\" alt=\"Image: Ville bli god på ski\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74468968&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=17.857142857143&amp;heighth=100&amp;heighty=0&amp;heightx=28.506787330317&amp;heightw=40.723981900452&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 dJUPJq title dynamic-sizing\">Ville bli</span><span class=\"pt8tzk-0 ktOFii title dynamic-sizing\">god på ski</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=\"Kjøpte duftspray på butikken - døde\" href=\"https://www.dagbladet.no/nyheter/kjopte-duftspray-pa-butikken---dode/74475586\"><figure class=\"sc-1an7vu1-0 hWJZyt\"><picture><img data-defer=\"view\" title=\"Image: Kjøpte duftspray på butikken - døde\" alt=\"Image: Kjøpte duftspray på butikken - døde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74476494&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=472\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dMquZC title dynamic-sizing\">Kjøpte duftspray</span><span class=\"pt8tzk-0 gSjNoe title dynamic-sizing\">på butikken - døde</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-12 medium-12 large-12 \" data-from=\"xavier\"><div id=\"ad-smartbanner2\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600], [980,300], [970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;smartbanner2&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slaktes etter SMS-avsløring\" href=\"https://www.dagbladet.no/nyheter/slaktes-etter-sms-avsloring/74477001\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Slaktes etter SMS-avsløring\" alt=\"Image: Slaktes etter SMS-avsløring\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74478929&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=18.571428571429&amp;heighty=0&amp;heightx=16.289592760181&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 lmuWME title dynamic-sizing\">Slaktes etter</span><span class=\"pt8tzk-0 bkQxHy title dynamic-sizing\">SMS-avsløring</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=\"Deler sjokkerende bilder fra sykesenga\" href=\"https://www.dagbladet.no/sport/deler-sjokkerende-bilder-fra-sykesenga/74474979\"><figure class=\"sc-1an7vu1-0 gkNcOt\"><picture><img data-defer=\"view\" title=\"Image: Deler sjokkerende bilder fra sykesenga\" alt=\"Image: Deler sjokkerende bilder fra sykesenga\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74474982&amp;panox=0&amp;panow=100&amp;panoh=34.466019417476&amp;panoy=17.47572815534&amp;heighty=0&amp;heightx=0&amp;heightw=60&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 clHgld title dynamic-sizing\">Deler sjokkerende</span><span class=\"pt8tzk-0 fXHPND title dynamic-sizing\">bilder fra sykesenga</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Funn av én omkommet\" href=\"https://www.dagbladet.no/nyheter/funn-av-n-omkommet/74493172\"><figure class=\"sc-1an7vu1-0 cHdpby\"><picture><img data-defer=\"view\" title=\"Image: Funn av én omkommet\" alt=\"Image: Funn av én omkommet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74493158&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=351\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 eEyqYx title dynamic-sizing\">Funn av én</span><span class=\"pt8tzk-0 fduMUN title dynamic-sizing\">omkommet</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=\"Ny allianse:- Uholdbart\" href=\"https://www.dagbladet.no/nyheter/ny-allianse--uholdbart/74476196\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Ny allianse:- Uholdbart\" alt=\"Image: Ny allianse:- Uholdbart\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73216398&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bbKwji title dynamic-sizing\">Ny allianse:-</span><span class=\"pt8tzk-0 gUvYku title dynamic-sizing\">Uholdbart</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=\"- Aldri sett før!\" href=\"https://www.dagbladet.no/video/-aldri-sett-for/Ccz0Nt2Y\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: - Aldri sett før!\" alt=\"Image: - Aldri sett før!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/Ccz0Nt2Y-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 bkotuw title dynamic-sizing\">- Aldri</span><span class=\"pt8tzk-0 dHiqVh title dynamic-sizing\">sett før!</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=\"Husker ikke livet før 2019\" href=\"https://www.dagbladet.no/tema/husker-ikke-livet-for-suksessen/74260981\"><figure class=\"sc-1an7vu1-0 jFciZD\"><picture><img data-defer=\"view\" title=\"Image: Husker ikke livet før 2019\" alt=\"Image: Husker ikke livet før 2019\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74266774&amp;panox=23.333333333333&amp;panow=51.785714285714&amp;panoh=11.778846153846&amp;panoy=33.12&amp;heighty=28.761904761905&amp;heightx=36.994219653179&amp;heightw=26.657060518732&amp;heighth=28.857142857143&amp;width=320&amp;height=251\" 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 Kvzvk title dynamic-sizing\">Husker ikke</span><span class=\"pt8tzk-0 VWhKg title dynamic-sizing\">livet før 2019</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=\"- Redd for å skuffe\" href=\"https://www.dagbladet.no/kultur/redd-for-a-skuffe/74484211\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: - Redd for å skuffe\" alt=\"Image: - Redd for å skuffe\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74486880&amp;panoy=13.362068965517&amp;panox=18.571428571429&amp;panow=60.288961142857&amp;panoh=31.039381034483&amp;heightx=31.205673758865&amp;heightw=32.273533333333&amp;heighth=79.150462032086&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 kwfIKj title dynamic-sizing\">- Redd for</span><span class=\"pt8tzk-0 khwVQb title dynamic-sizing\">å skuffe</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=\"Sparket fordi han er hvit mann\" href=\"https://www.dagbladet.no/nyheter/sparket-fordi-han-er-hvit-mann/74484540\"><figure class=\"sc-1an7vu1-0 kCxZsK\"><picture><img data-defer=\"view\" title=\"Image: Sparket fordi han er hvit mann\" alt=\"Image: Sparket fordi han er hvit mann\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74485399&amp;panow=92.372093023256&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heightw=92.372093023256&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=333\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 jHdOmf title dynamic-sizing\">Sparket fordi</span><span class=\"pt8tzk-0 bJaUWh title dynamic-sizing\">han er hvit mann</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=\"TikTok-stjerna (21) gravid for fjerde gang\" href=\"https://www.dagbladet.no/kjendis/tiktok-stjerna-21-gravid-for-fjerde-gang/74484040\"><figure class=\"sc-1an7vu1-0 iCFVAH\"><picture><img data-defer=\"view\" title=\"Image: TikTok-stjerna (21) gravid for fjerde gang\" alt=\"Image: TikTok-stjerna (21) gravid for fjerde gang\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74484533&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=256\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 jlskEK title dynamic-sizing\">TikTok-stjerna (21)</span><span class=\"pt8tzk-0 hBNdrH title dynamic-sizing\">gravid for fjerde gang</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=\"Flere influensere bryter alkoholloven\" href=\"https://www.dagbladet.no/kjendis/flere-influensere-bryter-alkoholloven/74475841\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Flere influensere bryter alkoholloven\" alt=\"Image: Flere influensere bryter alkoholloven\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74484932&amp;panoy=15.454545454545&amp;panox=0&amp;panow=100&amp;panoh=21.515151515152&amp;heightx=24.590163934426&amp;heightw=49.180327868852&amp;heighth=50.689655172414&amp;heighty=6.551724137931&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 csMjjt title dynamic-sizing\">Flere influensere</span><span class=\"pt8tzk-0 jlskEK title dynamic-sizing\">bryter alkoholloven</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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Viggo Kristiansens bevegelser utenfor fengselet\" href=\"https://www.dagbladet.no/nyheter/viggo-kristiansens-bevegelser-utenfor-fengselet/74467217\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Viggo Kristiansens bevegelser utenfor fengselet\" alt=\"Image: Viggo Kristiansens bevegelser utenfor fengselet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74468525&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" 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 iJqVoj title dynamic-sizing\">Viggo Kristiansens</span><span class=\"pt8tzk-0 hPWSFu title dynamic-sizing\">bevegelser</span><span class=\"pt8tzk-0 gdUHjZ title dynamic-sizing\">utenfor fengselet</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=\"Prøver kostyme - viser «alt»\" href=\"https://www.dagbladet.no/video/prover-kostyme-viser-alt/QRtFEPUu\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Prøver kostyme - viser «alt»\" alt=\"Image: Prøver kostyme - viser «alt»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/QRtFEPUu-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 zHZpy title dynamic-sizing\">Prøver kostyme</span><span class=\"pt8tzk-0 jzxvpJ title dynamic-sizing\">- viser «alt»</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=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"La luksus koste\" href=\"https://www.dagbladet.no/meninger/la-luksus-koste/74485457\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: La luksus koste\" alt=\"Image: La luksus koste\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=72463886&amp;panoh=50.574717241379&amp;panoy=25.51724137931&amp;panox=0.1536129032258&amp;panow=100.15361290323&amp;heightx=29.017857142857&amp;heightw=41.220241071429&amp;heighth=100.22371812081&amp;heighty=0.22371812080536&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kCJKgB title dynamic-sizing\">La luksus koste</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=\"Forbyr Squid Game-kostymer\" href=\"https://www.dagbladet.no/kultur/forbyr-squid-game-kostymer/74483603\"><figure class=\"sc-1an7vu1-0 lkDdqF\"><picture><img data-defer=\"view\" title=\"Image: Forbyr Squid Game-kostymer\" alt=\"Image: Forbyr Squid Game-kostymer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74344230&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=238\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 foNJuB title dynamic-sizing\">Forbyr Squid</span><span class=\"pt8tzk-0 jlskEK title dynamic-sizing\">Game-kostymer</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=\"Tiltalt for drap og kastrering på kjøkkenbordet\" href=\"https://www.dagbladet.no/nyheter/tiltalt-for-drap-og-kastrering-pa-kjokkenbordet/74483681\"><figure class=\"sc-1an7vu1-0 IPSiP\"><picture><img data-defer=\"view\" title=\"Image: Tiltalt for drap og kastrering på kjøkkenbordet\" alt=\"Image: Tiltalt for drap og kastrering på kjøkkenbordet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74483973&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=436\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gyvhMP title dynamic-sizing\">Tiltalt for drap</span><span class=\"pt8tzk-0 HUobe title dynamic-sizing\">og kastrering</span><span class=\"pt8tzk-0 lNXGQ title dynamic-sizing\">på kjøkkenbordet</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Vil bli foreldre\" href=\"https://www.dagbladet.no/kultur/jeg-vil-bli-pappa/74475609\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: - Vil bli foreldre\" alt=\"Image: - Vil bli foreldre\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74475724&amp;panow=72.569444444444&amp;panoh=16.136363636364&amp;panoy=7.7272727272727&amp;panox=7.9861111111111&amp;heighty=0&amp;heightx=24.528301886792&amp;heightw=42.452830188679&amp;heighth=44.954128440367&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 jsUlRE title dynamic-sizing\">- Vil bli</span><span class=\"pt8tzk-0 fCeQCp title dynamic-sizing\">foreldre</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=\"Idas (30) liv i hemmelig nettverk\" href=\"https://www.dagbladet.no/nyheter/idas-30-liv-i-hemmelig-nettverk/74292747\"><figure class=\"sc-1an7vu1-0 iJSWUD\"><picture><img data-defer=\"view\" title=\"Image: Idas (30) liv i hemmelig nettverk\" alt=\"Image: Idas (30) liv i hemmelig nettverk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74419141&amp;panoy=17.415730337079&amp;panow=86.166007905138&amp;panoh=41.573033707865&amp;panox=4.7430830039526&amp;heighty=7.8703703703704&amp;heightx=32.792207792208&amp;heightw=29.220779220779&amp;heighth=68.055555555556&amp;width=320&amp;height=180\" 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 dslBJt title dynamic-sizing\">Idas (30) liv i</span><span class=\"pt8tzk-0 iJqVoj title dynamic-sizing\">hemmelig nettverk</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=\"Avbryter plutselig intervjuet\" href=\"https://www.dagbladet.no/video/avbryter-plutselig-intervjuet/weTAUybb\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Avbryter plutselig intervjuet\" alt=\"Image: Avbryter plutselig intervjuet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/weTAUybb-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 lngSfY title dynamic-sizing\">Avbryter plutselig</span><span class=\"pt8tzk-0 dPJQg title dynamic-sizing\">intervjuet</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=\"Kjæresten bryter tausheten: - Ubeskrivelig\" href=\"https://www.dagbladet.no/kjendis/kjaeresten-bryter-tausheten---ubeskrivelig/74483508\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Kjæresten bryter tausheten: - Ubeskrivelig\" alt=\"Image: Kjæresten bryter tausheten: - Ubeskrivelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74483884&amp;panox=0&amp;panow=100&amp;panoh=33.649289099526&amp;panoy=6.6350710900474&amp;heightw=62.068965517241&amp;heighth=100&amp;heighty=0&amp;heightx=37.241379310345&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 csMjjt title dynamic-sizing\">Kjæresten bryter</span><span class=\"pt8tzk-0 FGTZX title dynamic-sizing\">tausheten:</span><span class=\"pt8tzk-0 iOqgmm title dynamic-sizing\">- Ubeskrivelig</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=\"Drikkekonkurranse ble aldri vist\" href=\"https://www.dagbladet.no/kultur/drikkekonkurranse-ble-aldri-vist/74484248\"><figure class=\"sc-1an7vu1-0 dZCBlL\"><picture><img data-defer=\"view\" title=\"Image: Drikkekonkurranse ble aldri vist\" alt=\"Image: Drikkekonkurranse ble aldri vist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74484395&amp;panoy=26.553672316384&amp;panox=0&amp;panow=96.888888888889&amp;panoh=41.80790960452&amp;heightw=48.453608247423&amp;heighty=0&amp;heightx=29.896907216495&amp;heighth=100&amp;width=485&amp;height=338\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 gKYxan title dynamic-sizing\">Drikkekonkurranse</span><span class=\"pt8tzk-0 jBrNzn title dynamic-sizing\">ble aldri vist</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=\"Mange rapporter om hjernetåke\" href=\"https://www.dagbladet.no/nyheter/mange-rapporter-om-hjernetake/74449044\"><figure class=\"sc-1an7vu1-0 jrmSqJ\"><picture><img data-defer=\"view\" title=\"Image: Mange rapporter om hjernetåke\" alt=\"Image: Mange rapporter om hjernetåke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74460603&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=100&amp;heightx=0&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=459\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 dMquZC title dynamic-sizing\">Mange rapporter</span><span class=\"pt8tzk-0 gyvhMP title dynamic-sizing\">om hjernetåke</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=\"Vekker oppsikt: Tusenvis av døde sjødyr\" href=\"https://www.dagbladet.no/nyheter/aldri-sett-noe-liknende/74465917\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Vekker oppsikt: Tusenvis av døde sjødyr\" alt=\"Image: Vekker oppsikt: Tusenvis av døde sjødyr\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74475017&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kCJKgB title dynamic-sizing\">Vekker oppsikt:</span><span class=\"pt8tzk-0 fjYhKA title dynamic-sizing\">Tusenvis av</span><span class=\"pt8tzk-0 iSUFlZ title dynamic-sizing\">døde sjødyr</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Latterliggjøres etter dette\" href=\"https://www.dagbladet.no/video/latterliggjores-etter-dette/GL24YfDP\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Latterliggjøres etter dette\" alt=\"Image: Latterliggjøres etter dette\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/GL24YfDP-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 kWQDJU title dynamic-sizing\">Latterliggjøres</span><span class=\"pt8tzk-0 bMVNYJ title dynamic-sizing\">etter dette</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Har to kjærester: – Trekantene hagler\" href=\"https://www.dagbladet.no/tema/har-to-kjaerester--trekantene-hagler/74274044\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Har to kjærester: – Trekantene hagler\" alt=\"Image: Har to kjærester: – Trekantene hagler\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74274728&amp;panoy=10.554089709763&amp;panow=76.315789473684&amp;panoh=19.393139841689&amp;panox=6.6666666666667&amp;heightx=10.44776119403&amp;heighty=0&amp;heightw=69.029850746269&amp;heighth=84.63687150838&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 dynFZO title dynamic-sizing\">Har to kjærester:</span><span class=\"pt8tzk-0 kJijAe title dynamic-sizing\">– Trekantene hagler</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=\"Venter massiv tidevannsflom\" href=\"https://www.dagbladet.no/nyheter/venter-massiv-tidevannsflom/74485274\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Venter massiv tidevannsflom\" alt=\"Image: Venter massiv tidevannsflom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74485940&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kLTsGD title dynamic-sizing\">Venter massiv</span><span class=\"pt8tzk-0 kLTsGD title dynamic-sizing\">tidevannsflom</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=\"Topper listene\" href=\"https://www.dagbladet.no/kultur/topper-listene/74484037\"><figure class=\"sc-1an7vu1-0 fxOLsM\"><picture><img data-defer=\"view\" title=\"Image: Topper listene\" alt=\"Image: Topper listene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74414637&amp;panox=0&amp;panow=98.642533936652&amp;panoh=33.484162895928&amp;panoy=17.647058823529&amp;heighty=0&amp;heightx=26.797385620915&amp;heightw=61.437908496732&amp;heighth=100&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 kLTsGD title dynamic-sizing\">Topper listene</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=\"Professor: Dette kan utløse MS\" href=\"https://www.dagbladet.no/tema/professor-dette-kan-utlose-ms/74291161\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Professor: Dette kan utløse MS\" alt=\"Image: Professor: Dette kan utløse MS\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74293357&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 cyyIav title dynamic-sizing\">Professor: Dette</span><span class=\"pt8tzk-0 bKgILb title dynamic-sizing\">kan utløse MS</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=\"FN overrasker med «skrekkvideo»\" href=\"https://www.dagbladet.no/video/fn-overrasker-med-skrekkvideo/FbfqWtQU\"><figure class=\"sc-1an7vu1-0 feaYkY\"><picture><img data-defer=\"view\" title=\"Image: FN overrasker med «skrekkvideo»\" alt=\"Image: FN overrasker med «skrekkvideo»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/FbfqWtQU-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 bKgILb title dynamic-sizing\">FN overrasker</span><span class=\"pt8tzk-0 efOKKV title dynamic-sizing\">med «skrekkvideo»</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=\"Fløy inn i farlige Tokagjelet: - Høy risiko\" href=\"https://www.dagbladet.no/nyheter/floy-inn-i-farlige-tokagjelet---hoy-risiko/74458795\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Fløy inn i farlige Tokagjelet: - Høy risiko\" alt=\"Image: Fløy inn i farlige Tokagjelet: - Høy risiko\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74468118&amp;panoy=3.7974683544304&amp;panow=100&amp;panoh=44.936708860759&amp;panox=0&amp;heighty=4.0540540540541&amp;heightx=52.702702702703&amp;heightw=30.405405405405&amp;heighth=66.216216216216&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 laaIGs title dynamic-sizing\">Fløy inn i farlige</span><span class=\"pt8tzk-0 dMquZC title dynamic-sizing\">Tokagjelet: - Høy risiko</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=\"- Knuser hjertet mitt\" href=\"https://www.dagbladet.no/sport/knuser-hjertet-mitt/74468485\"><figure class=\"sc-1an7vu1-0 clIACb\"><picture><img data-defer=\"view\" title=\"Image: - Knuser hjertet mitt\" alt=\"Image: - Knuser hjertet mitt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74448645&amp;panow=100&amp;panoy=29.285714285714&amp;panox=0&amp;panoh=50.714285714286&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=16.742081447964&amp;width=402&amp;height=231\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 hVsjqQ title dynamic-sizing\">- Knuser</span><span class=\"pt8tzk-0 kCJKgB title dynamic-sizing\">hjertet mitt</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører hemmelig date\" href=\"https://www.dagbladet.no/video/avslorer-hemmelig-date/QtnVxoSa\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Avslører hemmelig date\" alt=\"Image: Avslører hemmelig date\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/QtnVxoSa-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 gFUAmj title dynamic-sizing\">Avslører</span><span class=\"pt8tzk-0 gSjNoe title dynamic-sizing\">hemmelig date</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=\"- Folk kalte meg hore\" href=\"https://www.dagbladet.no/tema/ordene-som-odela-madeleines-25-liv/74229325\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: - Folk kalte meg hore\" alt=\"Image: - Folk kalte meg hore\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74250995&amp;panoy=14.788732394366&amp;panox=0&amp;panow=100&amp;panoh=50.354609929078&amp;heightw=100&amp;heighth=100&amp;heightx=0&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 jbzSci title dynamic-sizing\">- Folk kalte</span><span class=\"pt8tzk-0 kLTsGD title dynamic-sizing\">meg hore</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Jehovas-avhopper slår alarm\" href=\"https://www.dagbladet.no/tema/jehovas-vitner-avhopper-slar-alarm/74265392\"><figure class=\"sc-1an7vu1-0 HmzvL\"><picture><img data-defer=\"view\" title=\"Image: Jehovas-avhopper slår alarm\" alt=\"Image: Jehovas-avhopper slår alarm\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74306060&amp;panox=8.7301587301587&amp;panoy=24&amp;panow=83.730158730159&amp;panoh=41.142857142857&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=320&amp;height=192\" 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 iJqVoj title dynamic-sizing\">Jehovas-avhopper</span><span class=\"pt8tzk-0 bkQxHy title dynamic-sizing\">slår alarm</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Her velter vogntoget\" href=\"https://www.dagbladet.no/video/her-velter-vogntoget/szdH8pdj\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Her velter vogntoget\" alt=\"Image: Her velter vogntoget\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/szdH8pdj-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 dBWvKD title dynamic-sizing\">Her velter</span><span class=\"pt8tzk-0 ldAOMI title dynamic-sizing\">vogntoget</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=\"Kirurg sovnet under hasteoperasjon - beholder jobben\" href=\"https://www.dagbladet.no/nyheter/kirurg-sovnet-under-hasteoperasjon---beholder-jobben/74483976\"><figure class=\"sc-1an7vu1-0 crBzcL\"><picture><img data-defer=\"view\" title=\"Image: Kirurg sovnet under hasteoperasjon - beholder jobben\" alt=\"Image: Kirurg sovnet under hasteoperasjon - beholder jobben\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74484228&amp;panox=0&amp;panow=100&amp;panoh=85.779122541604&amp;panoy=0&amp;heightw=100&amp;heighth=85.779122541604&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 dRiDot title dynamic-sizing\">Kirurg sovnet under</span><span class=\"pt8tzk-0 foNJuB title dynamic-sizing\">hasteoperasjon</span><span class=\"pt8tzk-0 bDhNI title dynamic-sizing\">- beholder jobben</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=\"Kollapset etter mislykket slankekur\" href=\"https://www.dagbladet.no/sport/kollapset-etter-mislykket-slankekur/74416946\"><figure class=\"sc-1an7vu1-0 bfZJk\"><picture><img data-defer=\"view\" title=\"Image: Kollapset etter mislykket slankekur\" alt=\"Image: Kollapset etter mislykket slankekur\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74467582&amp;panow=100&amp;panoy=28.205128205128&amp;panox=0&amp;panoh=45.512820512821&amp;heightw=45.226130653266&amp;heighth=96.688741721854&amp;heighty=3.3112582781457&amp;heightx=25.628140703518&amp;width=485&amp;height=298\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 cGVeEg title dynamic-sizing\">Kollapset etter</span><span class=\"pt8tzk-0 dMquZC title dynamic-sizing\">mislykket slankekur</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Knekker i to\" href=\"https://www.dagbladet.no/video/knekker-i-to/LaHTkkYh\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Knekker i to\" alt=\"Image: Knekker i to\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/LaHTkkYh-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 Kvzvk title dynamic-sizing\">Knekker i to</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=\"Mannen som ble Martes redning\" href=\"https://www.dagbladet.no/sport/mannen-som-ble-martes-redning/74274384\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Mannen som ble Martes redning\" alt=\"Image: Mannen som ble Martes redning\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74294222&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" 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 cyyIav title dynamic-sizing\">Mannen som ble</span><span class=\"pt8tzk-0 hOtlMY title dynamic-sizing\">Martes redning</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=\"Dette skjer i «Stjernekamp»-kulissene\" href=\"https://www.dagbladet.no/kjendis/dette-skjer-i-stjernekamp-kulissene/74486605\"><figure class=\"sc-1an7vu1-0 cRpTTR\"><picture><img data-defer=\"view\" title=\"Image: Dette skjer i «Stjernekamp»-kulissene\" alt=\"Image: Dette skjer i «Stjernekamp»-kulissene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74486210&amp;panow=100&amp;panoh=50.704225352113&amp;panoy=7.7464788732394&amp;panox=0&amp;heightw=40.540540540541&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=402&amp;height=340\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kLTsGD title dynamic-sizing\">Dette skjer i</span><span class=\"pt8tzk-0 kJijAe title dynamic-sizing\">«Stjernekamp»-kulissene</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=\"Åpner opp om langrennsexiten\" href=\"https://www.dagbladet.no/sport/apner-opp-om-langrennsexiten/74477218\"><figure class=\"sc-1an7vu1-0 byyxXq\"><picture><img data-defer=\"view\" title=\"Image: Åpner opp om langrennsexiten\" alt=\"Image: Åpner opp om langrennsexiten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74478265&amp;panoh=50.714285714286&amp;panoy=36.428571428571&amp;panox=0&amp;panow=100&amp;heightx=37.556561085973&amp;heighty=0&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 kgUnLq title dynamic-sizing\">Åpner opp om</span><span class=\"pt8tzk-0 laaIGs title dynamic-sizing\">langrennsexiten</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=\"Tok fem grep – ble rik\" href=\"https://www.dagbladet.no/tema/tok-fem-grep---ble-rik/74227015\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Tok fem grep – ble rik\" alt=\"Image: Tok fem grep – ble rik\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74245108&amp;panoy=24.139046153846&amp;panox=0.46082949308756&amp;panow=100.46082949309&amp;panoh=22.769230769231&amp;heighth=64.016736401674&amp;heighty=12.55230125523&amp;heightx=24.050632911392&amp;heightw=59.493670886076&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 fXHPND title dynamic-sizing\">Tok fem grep</span><span class=\"pt8tzk-0 kClav title dynamic-sizing\">– ble rik</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=\"«Farmen»-flørten: - Ser helt krise ut\" href=\"https://www.dagbladet.no/video/farmen-florten-ser-helt-krise-ut/BoS8wJTF\"><figure class=\"sc-1an7vu1-0 ljMRWg\"><picture><img data-defer=\"view\" title=\"Image: «Farmen»-flørten: - Ser helt krise ut\" alt=\"Image: «Farmen»-flørten: - Ser helt krise ut\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/BoS8wJTF-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 gYwDTf title dynamic-sizing\">«Farmen»-flørten:</span><span class=\"pt8tzk-0 gdUHjZ title dynamic-sizing\">- Ser helt krise ut</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=\"Solgte sin kjæreste eiendel for å redde hunden\" href=\"https://www.dagbladet.no/nyheter/solgte-sin-kjaereste-eiendel-for-a-redde-hunden/74483905\"><figure class=\"sc-1an7vu1-0 cYyUrL\"><picture><img data-defer=\"view\" title=\"Image: Solgte sin kjæreste eiendel for å redde hunden\" alt=\"Image: Solgte sin kjæreste eiendel for å redde hunden\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74485419&amp;panox=0&amp;panow=100&amp;panoh=60.169491525424&amp;panoy=16.949152542373&amp;heightw=34.48275862069&amp;heighty=0&amp;heightx=43.295019157088&amp;heighth=100&amp;width=567&amp;height=305\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 bJaUWh title dynamic-sizing\">Solgte sin kjæreste</span><span class=\"pt8tzk-0 gSjNoe title dynamic-sizing\">eiendel for å redde hunden</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=\"- Vi er veldig glade\" href=\"https://www.dagbladet.no/kultur/vi-er-veldig-glade/74490131\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: - Vi er veldig glade\" alt=\"Image: - Vi er veldig glade\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74491783&amp;panox=40.597539543058&amp;panow=38.312829525483&amp;panoh=37.56345177665&amp;panoy=4.0609137055838&amp;heighty=12.371134020619&amp;heightx=43.986254295533&amp;heightw=32.302405498282&amp;heighth=78.865979381443&amp;width=402&amp;height=201\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 kiaerN title dynamic-sizing\">- Vi er</span><span class=\"pt8tzk-0 cGVeEg title dynamic-sizing\">veldig glade</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Raser\" href=\"https://www.dagbladet.no/video/raser/q6W9oDRk\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Raser\" alt=\"Image: Raser\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/q6W9oDRk-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 bGSxIf title dynamic-sizing\">Raser</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Jeg ble voldtatt\" href=\"https://www.dagbladet.no/tema/jeg-ble-voldtatt/74302426\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: - Jeg ble voldtatt\" alt=\"Image: - Jeg ble voldtatt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74304464&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heightx=9.1324200913242&amp;heighty=0&amp;heightw=41.095890410959&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 kCJKgB title dynamic-sizing\">- Jeg ble</span><span class=\"pt8tzk-0 giZETU title dynamic-sizing\">voldtatt</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fondet som gjør Lise (34) rik\" href=\"https://www.dagbladet.no/tema/fondet-som-gjor-lise-34-rik/74393070\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Fondet som gjør Lise (34) rik\" alt=\"Image: Fondet som gjør Lise (34) rik\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74399041&amp;panoh=51.428571428571&amp;panoy=29.285714285714&amp;panox=0&amp;panow=100&amp;heighty=0&amp;heightx=32.126696832579&amp;heightw=40.723981900452&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 zHZpy title dynamic-sizing\">Fondet som gjør</span><span class=\"pt8tzk-0 Kvzvk title dynamic-sizing\">Lise (34) rik</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=\"Angriper treneren: - Utrolig trist\" href=\"https://www.dagbladet.no/video/angriper-treneren-utrolig-trist/JI8s3DVX\"><figure class=\"sc-1an7vu1-0 jxGDqV\"><picture><img data-defer=\"view\" title=\"Image: Angriper treneren: - Utrolig trist\" alt=\"Image: Angriper treneren: - Utrolig trist\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/JI8s3DVX-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 cilyqE title dynamic-sizing\">Angriper treneren:</span><span class=\"pt8tzk-0 dslBJt title dynamic-sizing\">- Utrolig trist</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=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Må hjelpe tigeren\" href=\"https://www.dagbladet.no/video/ma-hjelpe-tigeren/FK83q0Yu\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Må hjelpe tigeren\" alt=\"Image: Må hjelpe tigeren\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/FK83q0Yu-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 OMVyn title dynamic-sizing\">Må hjelpe</span><span class=\"pt8tzk-0 fsCidJ title dynamic-sizing\">tigeren</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=\"Mange rammes: - Slik endres AFP\" href=\"https://www.dagbladet.no/tema/dette-skjer-med-pensjonen-din---slik-endres-afp/74196565\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Mange rammes: - Slik endres AFP\" alt=\"Image: Mange rammes: - Slik endres AFP\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74189109&amp;panoy=25.179856115108&amp;panox=0&amp;panow=100&amp;panoh=25.539568345324&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div>0</figure><header><h3 class=\"xavier-headline headline\"><span class=\"pt8tzk-0 zHZpy title dynamic-sizing\">Mange rammes:</span><span class=\"pt8tzk-0 gdUHjZ title dynamic-sizing\">- Slik endres AFP</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Lege: Ett middel stopper hårtap\" href=\"https://www.dagbladet.no/tema/lege-ett-middel-stopper-hartap/74303913\"><figure class=\"sc-1an7vu1-0 bNCpt\"><picture><img data-defer=\"view\" title=\"Image: Lege: Ett middel stopper hårtap\" alt=\"Image: Lege: Ett middel stopper hårtap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74399288&amp;panoy=10.810810810811&amp;panow=100&amp;panoh=63.963963963964&amp;panox=0&amp;heighty=0&amp;heightx=40.501792114695&amp;heightw=32.258064516129&amp;heighth=100&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 zHZpy title dynamic-sizing\">Lege: Ett middel</span><span class=\"pt8tzk-0 kWQDJU title dynamic-sizing\">stopper hårtap</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=\"Blir truffet - så klikker han\" href=\"https://www.dagbladet.no/video/blir-truffet-sa-klikker-han/CwVUyusJ\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Blir truffet - så klikker han\" alt=\"Image: Blir truffet - så klikker han\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/CwVUyusJ-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 Kvzvk title dynamic-sizing\">Blir truffet -</span><span class=\"pt8tzk-0 bKgILb title dynamic-sizing\">så klikker han</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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"SUV-favoritten: Derfor hylles Y\" href=\"https://www.dagbladet.no/tema/suv-favorittene-derfor-hylles-tesla-y/74208755\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: SUV-favoritten: Derfor hylles Y\" alt=\"Image: SUV-favoritten: Derfor hylles Y\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74208779&amp;panoy=65.934065934066&amp;panox=0&amp;panow=100&amp;panoh=26.373626373626&amp;heighty=11.299435028249&amp;heightx=4.4444444444444&amp;heightw=67.407407407407&amp;heighth=83.61581920904&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 jNjUxV title dynamic-sizing\">SUV-favoritten:</span><span class=\"pt8tzk-0 gSjNoe title dynamic-sizing\">Derfor hylles Y</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=\"- Hysterisk!\" href=\"https://www.dagbladet.no/video/-hysterisk/jMmBqprQ\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: - Hysterisk!\" alt=\"Image: - Hysterisk!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/jMmBqprQ-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 jzxvpJ title dynamic-sizing\">- Hysterisk!</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=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ned 35 kilo – dietten overrasker\" href=\"https://www.dagbladet.no/tema/else-ned-35-kilo-uten-kaloritelling/74264239\"><figure class=\"sc-1an7vu1-0 krISuO\"><picture><img data-defer=\"view\" title=\"Image: Ned 35 kilo – dietten overrasker\" alt=\"Image: Ned 35 kilo – dietten overrasker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=74290175&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heightx=37.847222222222&amp;heightw=31.25&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=219\" 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 fXHPND title dynamic-sizing\">Ned 35 kilo –</span><span class=\"pt8tzk-0 lngSfY title dynamic-sizing\">dietten overrasker</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=\"Hunder fanget av lava\" href=\"https://www.dagbladet.no/video/hunder-fanget-av-lava/GPnElzWj\"><figure class=\"sc-1an7vu1-0 dhguxo\"><picture><img data-defer=\"view\" title=\"Image: Hunder fanget av lava\" alt=\"Image: Hunder fanget av lava\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/GPnElzWj-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 kWQDJU title dynamic-sizing\">Hunder fanget</span><span class=\"pt8tzk-0 TWGab title dynamic-sizing\">av lava</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>"]
lukk
dagbladet er en del av Aller Media
Hvorfor ser du denne annonsen
Nettstedet du nå besøker blir i stor del finansiert av annonseinntekter. Basert på din tidligere aktivitet hos oss, vil du få annonser vi tror kan interessere deg.
Du velger selv om du ønsker å endre dine innstillinger
Om Aller Media og annonsering
Aller Media eier nettstedene Dagbladet, Sol, DinSide, KK, Se og Hør, Lommelegen, Topp og Vi
Vi bryr oss om ditt personvern
dagbladet er en del av Aller Media, som er ansvarlig for dine data. Vi
bruker dataene til å forbedre og tilpasse tjenestene, tilbudene og annonsene
våre.