
-
Helsedirektoratet presiserer angående hytteturer
-
Helsedirektoratet anbefaler strenge smittetiltak i 15 kommuner
-
Brann på togstasjon
-
Solberg: - Kan ha det verste foran oss
-
Høie: - Vi er klare til kamp
-
Nakstad svarer leserne
-
25 millioner coronatilfeller i USA
-
Frank: Skader for 30 mill
-
Helse Vest: Pasienter fra Østlandet isoleres
-
Kontroll på utbrudd på sykehjem i Nordre Follo

- Fy faen!

Ny artrosebehandlinghjalp Ragnar (83)
Annonsørinnhold

Ustabil WiFi?Slik løses det
i samarbeid med
Røper genialt grep
SE NÅ:

Slapp unna med skrekktakling
SE NÅ:

Scoret etter tabbe
SE NÅ:

Sylfrekk scoring

Født medsjelden sykdom
Protein-kildevekker oppsikt
Annonsørinnhold


Spar tusenlapperpå lån nå
i samarbeid medHelse Sør-Øst med drastiske tiltak
BRente «Mette F»:

Tre pågrepet
pressekonferanse klokka 21:

Strammer trolig inn
["<style data-styled=\"true\" data-styled-version=\"5.2.1\">.fptXsJ.fptXsJ.fptXsJ.fptXsJ{height:0;padding-bottom:50%;}/*!sc*/ .cVlffi.cVlffi.cVlffi.cVlffi{height:0;padding-bottom:49.89%;}/*!sc*/ .ryQzk.ryQzk.ryQzk.ryQzk{height:0;padding-bottom:56.49%;}/*!sc*/ .kVLbii.kVLbii.kVLbii.kVLbii{height:0;padding-bottom:79.17%;}/*!sc*/ .lfdmgf.lfdmgf.lfdmgf.lfdmgf{height:0;padding-bottom:62.81%;}/*!sc*/ .LNrJj.LNrJj.LNrJj.LNrJj{height:0;padding-bottom:49.91%;}/*!sc*/ .fREbZN.fREbZN.fREbZN.fREbZN{height:0;padding-bottom:55.47%;}/*!sc*/ .hPCeKL.hPCeKL.hPCeKL.hPCeKL{height:0;padding-bottom:66.41%;}/*!sc*/ .fZtJip.fZtJip.fZtJip.fZtJip{height:0;padding-bottom:50.93%;}/*!sc*/ .dauuSl.dauuSl.dauuSl.dauuSl{height:0;padding-bottom:56.08%;}/*!sc*/ .taCYg.taCYg.taCYg.taCYg{height:0;padding-bottom:78.1%;}/*!sc*/ .blDduk.blDduk.blDduk.blDduk{height:0;padding-bottom:108.12%;}/*!sc*/ .elXDbt.elXDbt.elXDbt.elXDbt{height:0;padding-bottom:74.37%;}/*!sc*/ .knzTC.knzTC.knzTC.knzTC{height:0;padding-bottom:52.16%;}/*!sc*/ .tXCDm.tXCDm.tXCDm.tXCDm{height:0;padding-bottom:68.86%;}/*!sc*/ .fTBjDc.fTBjDc.fTBjDc.fTBjDc{height:0;padding-bottom:91.79%;}/*!sc*/ .htYqxw.htYqxw.htYqxw.htYqxw{height:0;padding-bottom:89.3%;}/*!sc*/ .dcXyHK.dcXyHK.dcXyHK.dcXyHK{height:0;padding-bottom:61.87%;}/*!sc*/ .eMBUIR.eMBUIR.eMBUIR.eMBUIR{height:0;padding-bottom:70.62%;}/*!sc*/ .jnPmsV.jnPmsV.jnPmsV.jnPmsV{height:0;padding-bottom:61.44%;}/*!sc*/ .kBBPoW.kBBPoW.kBBPoW.kBBPoW{height:0;padding-bottom:90.54%;}/*!sc*/ .hlMjpg.hlMjpg.hlMjpg.hlMjpg{height:0;padding-bottom:53.4%;}/*!sc*/ .dmTTiz.dmTTiz.dmTTiz.dmTTiz{height:0;padding-bottom:78.6%;}/*!sc*/ .jJclyb.jJclyb.jJclyb.jJclyb{height:0;padding-bottom:69.68%;}/*!sc*/ .OIImT.OIImT.OIImT.OIImT{height:0;padding-bottom:63.91%;}/*!sc*/ .bmkgwI.bmkgwI.bmkgwI.bmkgwI{height:0;padding-bottom:97.73%;}/*!sc*/ .dzEIYn.dzEIYn.dzEIYn.dzEIYn{height:0;padding-bottom:54.37%;}/*!sc*/ .dsCdew.dsCdew.dsCdew.dsCdew{height:0;padding-bottom:50.74%;}/*!sc*/ .fCgDzX.fCgDzX.fCgDzX.fCgDzX{height:0;padding-bottom:56.71%;}/*!sc*/ .jULjqn.jULjqn.jULjqn.jULjqn{height:0;padding-bottom:86.56%;}/*!sc*/ .hSyFSz.hSyFSz.hSyFSz.hSyFSz{height:0;padding-bottom:86.25%;}/*!sc*/ .cLImwa.cLImwa.cLImwa.cLImwa{height:0;padding-bottom:68.24%;}/*!sc*/ .dLMKhl.dLMKhl.dLMKhl.dLMKhl{height:0;padding-bottom:77.52%;}/*!sc*/ .gHjwGX.gHjwGX.gHjwGX.gHjwGX{height:0;padding-bottom:53.43%;}/*!sc*/ .bnFcMN.bnFcMN.bnFcMN.bnFcMN{height:0;padding-bottom:109.7%;}/*!sc*/ .cmoThx.cmoThx.cmoThx.cmoThx{height:0;padding-bottom:51.25%;}/*!sc*/ .HqEmi.HqEmi.HqEmi.HqEmi{height:0;padding-bottom:58.14%;}/*!sc*/ .llqYGt.llqYGt.llqYGt.llqYGt{height:0;padding-bottom:62.43%;}/*!sc*/ .jsBxvK.jsBxvK.jsBxvK.jsBxvK{height:0;padding-bottom:60%;}/*!sc*/ .eyhIPs.eyhIPs.eyhIPs.eyhIPs{height:0;padding-bottom:101.24%;}/*!sc*/ .kcBjlq.kcBjlq.kcBjlq.kcBjlq{height:0;padding-bottom:60.93%;}/*!sc*/ .dauBDf.dauBDf.dauBDf.dauBDf{height:0;padding-bottom:70%;}/*!sc*/ .gSiDQc.gSiDQc.gSiDQc.gSiDQc{height:0;padding-bottom:80.31%;}/*!sc*/ data-styled.g21[id=\"sc-1gprk7r-0\"]{content:\"fptXsJ,cVlffi,ryQzk,kVLbii,lfdmgf,LNrJj,fREbZN,hPCeKL,fZtJip,dauuSl,taCYg,blDduk,elXDbt,knzTC,tXCDm,fTBjDc,htYqxw,dcXyHK,eMBUIR,jnPmsV,kBBPoW,hlMjpg,dmTTiz,jJclyb,OIImT,bmkgwI,dzEIYn,dsCdew,fCgDzX,jULjqn,hSyFSz,cLImwa,dLMKhl,gHjwGX,bnFcMN,cmoThx,HqEmi,llqYGt,jsBxvK,eyhIPs,kcBjlq,dauBDf,gSiDQc,\"}/*!sc*/ .YuxpH.YuxpH.YuxpH.YuxpH{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.YuxpH.YuxpH.YuxpH.YuxpH{font-size:1em!important;}}/*!sc*/ .kPzQUo.kPzQUo.kPzQUo.kPzQUo{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.kPzQUo.kPzQUo.kPzQUo.kPzQUo{font-size:1.5em!important;}}/*!sc*/ .iXUXMA.iXUXMA.iXUXMA.iXUXMA{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.iXUXMA.iXUXMA.iXUXMA.iXUXMA{font-size:1em!important;}}/*!sc*/ .gtTUxB.gtTUxB.gtTUxB.gtTUxB{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.gtTUxB.gtTUxB.gtTUxB.gtTUxB{font-size:1.1em!important;}}/*!sc*/ .jImAQx.jImAQx.jImAQx.jImAQx{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jImAQx.jImAQx.jImAQx.jImAQx{font-size:2em!important;}}/*!sc*/ .kWXIHq.kWXIHq.kWXIHq.kWXIHq{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kWXIHq.kWXIHq.kWXIHq.kWXIHq{font-size:1.2em!important;}}/*!sc*/ .dkLtKc.dkLtKc.dkLtKc.dkLtKc{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dkLtKc.dkLtKc.dkLtKc.dkLtKc{font-size:1.1em!important;}}/*!sc*/ .dIxxkx.dIxxkx.dIxxkx.dIxxkx{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dIxxkx.dIxxkx.dIxxkx.dIxxkx{font-size:1.4em!important;}}/*!sc*/ .dhVPLY.dhVPLY.dhVPLY.dhVPLY{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dhVPLY.dhVPLY.dhVPLY.dhVPLY{font-size:1.3em!important;}}/*!sc*/ .goyPlf.goyPlf.goyPlf.goyPlf{font-size:8.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.goyPlf.goyPlf.goyPlf.goyPlf{font-size:3em!important;}}/*!sc*/ .gwXtNi.gwXtNi.gwXtNi.gwXtNi{font-size:7.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.gwXtNi.gwXtNi.gwXtNi.gwXtNi{font-size:2.7em!important;}}/*!sc*/ .eUDXpR.eUDXpR.eUDXpR.eUDXpR{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.eUDXpR.eUDXpR.eUDXpR.eUDXpR{font-size:1.2em!important;}}/*!sc*/ .gOMQzB.gOMQzB.gOMQzB.gOMQzB{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gOMQzB.gOMQzB.gOMQzB.gOMQzB{font-size:1.8em!important;}}/*!sc*/ .eDBixd.eDBixd.eDBixd.eDBixd{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eDBixd.eDBixd.eDBixd.eDBixd{font-size:0.8em!important;}}/*!sc*/ .bfzPjL.bfzPjL.bfzPjL.bfzPjL{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bfzPjL.bfzPjL.bfzPjL.bfzPjL{font-size:1.2em!important;}}/*!sc*/ .ivfiEr.ivfiEr.ivfiEr.ivfiEr{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ivfiEr.ivfiEr.ivfiEr.ivfiEr{font-size:1.3em!important;}}/*!sc*/ .jefjkY.jefjkY.jefjkY.jefjkY{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jefjkY.jefjkY.jefjkY.jefjkY{font-size:1.7em!important;}}/*!sc*/ .BSpIV.BSpIV.BSpIV.BSpIV{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.BSpIV.BSpIV.BSpIV.BSpIV{font-size:2.1em!important;}}/*!sc*/ .jlGXXG.jlGXXG.jlGXXG.jlGXXG{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jlGXXG.jlGXXG.jlGXXG.jlGXXG{font-size:2.1em!important;}}/*!sc*/ .kQgxdX.kQgxdX.kQgxdX.kQgxdX{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kQgxdX.kQgxdX.kQgxdX.kQgxdX{font-size:1.7em!important;}}/*!sc*/ .jZAQlv.jZAQlv.jZAQlv.jZAQlv{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jZAQlv.jZAQlv.jZAQlv.jZAQlv{font-size:2em!important;}}/*!sc*/ .fNoJSh.fNoJSh.fNoJSh.fNoJSh{font-size:9.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.fNoJSh.fNoJSh.fNoJSh.fNoJSh{font-size:3.5em!important;}}/*!sc*/ .fLRKWS.fLRKWS.fLRKWS.fLRKWS{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fLRKWS.fLRKWS.fLRKWS.fLRKWS{font-size:0.9em!important;}}/*!sc*/ .dYVUKX.dYVUKX.dYVUKX.dYVUKX{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.dYVUKX.dYVUKX.dYVUKX.dYVUKX{font-size:1.1em!important;}}/*!sc*/ .kEABPd.kEABPd.kEABPd.kEABPd{font-size:2.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kEABPd.kEABPd.kEABPd.kEABPd{font-size:0.7em!important;}}/*!sc*/ .lmKcnW.lmKcnW.lmKcnW.lmKcnW{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.lmKcnW.lmKcnW.lmKcnW.lmKcnW{font-size:1em!important;}}/*!sc*/ .cONGAH.cONGAH.cONGAH.cONGAH{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.cONGAH.cONGAH.cONGAH.cONGAH{font-size:1.9em!important;}}/*!sc*/ .lbIvFp.lbIvFp.lbIvFp.lbIvFp{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.lbIvFp.lbIvFp.lbIvFp.lbIvFp{font-size:1.7em!important;}}/*!sc*/ .cODKTG.cODKTG.cODKTG.cODKTG{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.cODKTG.cODKTG.cODKTG.cODKTG{font-size:2.4em!important;}}/*!sc*/ .huVjzL.huVjzL.huVjzL.huVjzL{font-size:9.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.huVjzL.huVjzL.huVjzL.huVjzL{font-size:3.6em!important;}}/*!sc*/ .gvivVM.gvivVM.gvivVM.gvivVM{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.gvivVM.gvivVM.gvivVM.gvivVM{font-size:1.7em!important;}}/*!sc*/ .tTqiK.tTqiK.tTqiK.tTqiK{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.tTqiK.tTqiK.tTqiK.tTqiK{font-size:1.5em!important;}}/*!sc*/ .fcOaLE.fcOaLE.fcOaLE.fcOaLE{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fcOaLE.fcOaLE.fcOaLE.fcOaLE{font-size:0.5em!important;}}/*!sc*/ .kVyWiO.kVyWiO.kVyWiO.kVyWiO{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kVyWiO.kVyWiO.kVyWiO.kVyWiO{font-size:1.3em!important;}}/*!sc*/ .impgzW.impgzW.impgzW.impgzW{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.impgzW.impgzW.impgzW.impgzW{font-size:1.4em!important;}}/*!sc*/ .hoeVhK.hoeVhK.hoeVhK.hoeVhK{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.hoeVhK.hoeVhK.hoeVhK.hoeVhK{font-size:2.2em!important;}}/*!sc*/ .gyclYO.gyclYO.gyclYO.gyclYO{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gyclYO.gyclYO.gyclYO.gyclYO{font-size:1.1em!important;}}/*!sc*/ .DJrhN.DJrhN.DJrhN.DJrhN{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.DJrhN.DJrhN.DJrhN.DJrhN{font-size:1.5em!important;}}/*!sc*/ .fnTXOy.fnTXOy.fnTXOy.fnTXOy{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.fnTXOy.fnTXOy.fnTXOy.fnTXOy{font-size:1.9em!important;}}/*!sc*/ .jUorVM.jUorVM.jUorVM.jUorVM{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jUorVM.jUorVM.jUorVM.jUorVM{font-size:1.5em!important;}}/*!sc*/ .irCLxI.irCLxI.irCLxI.irCLxI{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.irCLxI.irCLxI.irCLxI.irCLxI{font-size:1.5em!important;}}/*!sc*/ .kihcRj.kihcRj.kihcRj.kihcRj{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.kihcRj.kihcRj.kihcRj.kihcRj{font-size:2.2em!important;}}/*!sc*/ .eOrgrB.eOrgrB.eOrgrB.eOrgrB{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.eOrgrB.eOrgrB.eOrgrB.eOrgrB{font-size:0.6em!important;}}/*!sc*/ .dIUEjq.dIUEjq.dIUEjq.dIUEjq{font-size:7.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dIUEjq.dIUEjq.dIUEjq.dIUEjq{font-size:2.8em!important;}}/*!sc*/ .dzspVx.dzspVx.dzspVx.dzspVx{font-size:10.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.dzspVx.dzspVx.dzspVx.dzspVx{font-size:3.9em!important;}}/*!sc*/ .djJIro.djJIro.djJIro.djJIro{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.djJIro.djJIro.djJIro.djJIro{font-size:2.5em!important;}}/*!sc*/ .BsdKn.BsdKn.BsdKn.BsdKn{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.BsdKn.BsdKn.BsdKn.BsdKn{font-size:0.9em!important;}}/*!sc*/ .eycHRp.eycHRp.eycHRp.eycHRp{font-size:6em!important;}/*!sc*/ @media only screen and (max-width:640px){.eycHRp.eycHRp.eycHRp.eycHRp{font-size:2.1em!important;}}/*!sc*/ .dEDsKr.dEDsKr.dEDsKr.dEDsKr{font-size:8.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.dEDsKr.dEDsKr.dEDsKr.dEDsKr{font-size:2.9em!important;}}/*!sc*/ .eEIScg.eEIScg.eEIScg.eEIScg{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.eEIScg.eEIScg.eEIScg.eEIScg{font-size:1.8em!important;}}/*!sc*/ .jcwTZx.jcwTZx.jcwTZx.jcwTZx{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jcwTZx.jcwTZx.jcwTZx.jcwTZx{font-size:0.9em!important;}}/*!sc*/ .bSTtWv.bSTtWv.bSTtWv.bSTtWv{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bSTtWv.bSTtWv.bSTtWv.bSTtWv{font-size:1.2em!important;}}/*!sc*/ .efqLUy.efqLUy.efqLUy.efqLUy{font-size:7.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.efqLUy.efqLUy.efqLUy.efqLUy{font-size:2.4em!important;}}/*!sc*/ .cTGhck.cTGhck.cTGhck.cTGhck{font-size:8.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.cTGhck.cTGhck.cTGhck.cTGhck{font-size:2.9em!important;}}/*!sc*/ .jkEAqG.jkEAqG.jkEAqG.jkEAqG{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jkEAqG.jkEAqG.jkEAqG.jkEAqG{font-size:2.6em!important;}}/*!sc*/ .ZDmxx.ZDmxx.ZDmxx.ZDmxx{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.ZDmxx.ZDmxx.ZDmxx.ZDmxx{font-size:1.4em!important;}}/*!sc*/ .TkEVY.TkEVY.TkEVY.TkEVY{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.TkEVY.TkEVY.TkEVY.TkEVY{font-size:2em!important;}}/*!sc*/ .inUiNS.inUiNS.inUiNS.inUiNS{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.inUiNS.inUiNS.inUiNS.inUiNS{font-size:1.3em!important;}}/*!sc*/ .fFRTMI.fFRTMI.fFRTMI.fFRTMI{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.fFRTMI.fFRTMI.fFRTMI.fFRTMI{font-size:1.6em!important;}}/*!sc*/ .ccvPZD.ccvPZD.ccvPZD.ccvPZD{font-size:9.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.ccvPZD.ccvPZD.ccvPZD.ccvPZD{font-size:3.4em!important;}}/*!sc*/ .fDBDCY.fDBDCY.fDBDCY.fDBDCY{font-size:8.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fDBDCY.fDBDCY.fDBDCY.fDBDCY{font-size:3em!important;}}/*!sc*/ .fDcJjc.fDcJjc.fDcJjc.fDcJjc{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fDcJjc.fDcJjc.fDcJjc.fDcJjc{font-size:2.4em!important;}}/*!sc*/ .bTXZyv.bTXZyv.bTXZyv.bTXZyv{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bTXZyv.bTXZyv.bTXZyv.bTXZyv{font-size:1.7em!important;}}/*!sc*/ .hVNEqT.hVNEqT.hVNEqT.hVNEqT{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.hVNEqT.hVNEqT.hVNEqT.hVNEqT{font-size:1.8em!important;}}/*!sc*/ .kWXxpK.kWXxpK.kWXxpK.kWXxpK{font-size:1.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kWXxpK.kWXxpK.kWXxpK.kWXxpK{font-size:0.5em!important;}}/*!sc*/ .eyrdmg.eyrdmg.eyrdmg.eyrdmg{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.eyrdmg.eyrdmg.eyrdmg.eyrdmg{font-size:0.7em!important;}}/*!sc*/ .bvdCLB.bvdCLB.bvdCLB.bvdCLB{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvdCLB.bvdCLB.bvdCLB.bvdCLB{font-size:1.4em!important;}}/*!sc*/ .hMrDZB.hMrDZB.hMrDZB.hMrDZB{font-size:4.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.hMrDZB.hMrDZB.hMrDZB.hMrDZB{font-size:1.6em!important;}}/*!sc*/ .itSNar.itSNar.itSNar.itSNar{font-size:1.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.itSNar.itSNar.itSNar.itSNar{font-size:0.5em!important;}}/*!sc*/ .etvWFx.etvWFx.etvWFx.etvWFx{font-size:7.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.etvWFx.etvWFx.etvWFx.etvWFx{font-size:2.4em!important;}}/*!sc*/ .biAQET.biAQET.biAQET.biAQET{font-size:7.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.biAQET.biAQET.biAQET.biAQET{font-size:2.8em!important;}}/*!sc*/ .etpsbw.etpsbw.etpsbw.etpsbw{font-size:9.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.etpsbw.etpsbw.etpsbw.etpsbw{font-size:3.2em!important;}}/*!sc*/ .iNnJvR.iNnJvR.iNnJvR.iNnJvR{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.iNnJvR.iNnJvR.iNnJvR.iNnJvR{font-size:1em!important;}}/*!sc*/ .jzNSzo.jzNSzo.jzNSzo.jzNSzo{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.jzNSzo.jzNSzo.jzNSzo.jzNSzo{font-size:0.9em!important;}}/*!sc*/ .fvFFOw.fvFFOw.fvFFOw.fvFFOw{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fvFFOw.fvFFOw.fvFFOw.fvFFOw{font-size:2.5em!important;}}/*!sc*/ .GhgRK.GhgRK.GhgRK.GhgRK{font-size:8.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.GhgRK.GhgRK.GhgRK.GhgRK{font-size:3.3em!important;}}/*!sc*/ .iqlpQx.iqlpQx.iqlpQx.iqlpQx{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.iqlpQx.iqlpQx.iqlpQx.iqlpQx{font-size:0.9em!important;}}/*!sc*/ .bOgtno.bOgtno.bOgtno.bOgtno{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bOgtno.bOgtno.bOgtno.bOgtno{font-size:1.2em!important;}}/*!sc*/ .bwUkXo.bwUkXo.bwUkXo.bwUkXo{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwUkXo.bwUkXo.bwUkXo.bwUkXo{font-size:1.4em!important;}}/*!sc*/ .hrdHBu.hrdHBu.hrdHBu.hrdHBu{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.hrdHBu.hrdHBu.hrdHBu.hrdHBu{font-size:1.4em!important;}}/*!sc*/ .jHkMMn.jHkMMn.jHkMMn.jHkMMn{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jHkMMn.jHkMMn.jHkMMn.jHkMMn{font-size:1.1em!important;}}/*!sc*/ .gUQkCx.gUQkCx.gUQkCx.gUQkCx{font-size:6.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.gUQkCx.gUQkCx.gUQkCx.gUQkCx{font-size:2.2em!important;}}/*!sc*/ .bXvGRf.bXvGRf.bXvGRf.bXvGRf{font-size:6.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bXvGRf.bXvGRf.bXvGRf.bXvGRf{font-size:2.3em!important;}}/*!sc*/ .cEKzMg.cEKzMg.cEKzMg.cEKzMg{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.cEKzMg.cEKzMg.cEKzMg.cEKzMg{font-size:0.8em!important;}}/*!sc*/ .ciDiKz.ciDiKz.ciDiKz.ciDiKz{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.ciDiKz.ciDiKz.ciDiKz.ciDiKz{font-size:0.8em!important;}}/*!sc*/ .crfreL.crfreL.crfreL.crfreL{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.crfreL.crfreL.crfreL.crfreL{font-size:1.6em!important;}}/*!sc*/ .iTalLs.iTalLs.iTalLs.iTalLs{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iTalLs.iTalLs.iTalLs.iTalLs{font-size:1.1em!important;}}/*!sc*/ .jMoSXp.jMoSXp.jMoSXp.jMoSXp{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jMoSXp.jMoSXp.jMoSXp.jMoSXp{font-size:2.3em!important;}}/*!sc*/ .eLwWzi.eLwWzi.eLwWzi.eLwWzi{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.eLwWzi.eLwWzi.eLwWzi.eLwWzi{font-size:2.8em!important;}}/*!sc*/ .hwvloE.hwvloE.hwvloE.hwvloE{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.hwvloE.hwvloE.hwvloE.hwvloE{font-size:1.2em!important;}}/*!sc*/ .wFIQJ.wFIQJ.wFIQJ.wFIQJ{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.wFIQJ.wFIQJ.wFIQJ.wFIQJ{font-size:1.6em!important;}}/*!sc*/ .eaOcSY.eaOcSY.eaOcSY.eaOcSY{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.eaOcSY.eaOcSY.eaOcSY.eaOcSY{font-size:2.2em!important;}}/*!sc*/ .hoKTVY.hoKTVY.hoKTVY.hoKTVY{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.hoKTVY.hoKTVY.hoKTVY.hoKTVY{font-size:0.6em!important;}}/*!sc*/ .fSbsaS.fSbsaS.fSbsaS.fSbsaS{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fSbsaS.fSbsaS.fSbsaS.fSbsaS{font-size:0.8em!important;}}/*!sc*/ data-styled.g22[id=\"sc-226e87-0\"]{content:\"YuxpH,kPzQUo,iXUXMA,gtTUxB,jImAQx,kWXIHq,dkLtKc,dIxxkx,dhVPLY,goyPlf,gwXtNi,eUDXpR,gOMQzB,eDBixd,bfzPjL,ivfiEr,jefjkY,BSpIV,jlGXXG,kQgxdX,jZAQlv,fNoJSh,fLRKWS,dYVUKX,kEABPd,lmKcnW,cONGAH,lbIvFp,cODKTG,huVjzL,gvivVM,tTqiK,fcOaLE,kVyWiO,impgzW,hoeVhK,gyclYO,DJrhN,fnTXOy,jUorVM,irCLxI,kihcRj,eOrgrB,dIUEjq,dzspVx,djJIro,BsdKn,eycHRp,dEDsKr,eEIScg,jcwTZx,bSTtWv,efqLUy,cTGhck,jkEAqG,ZDmxx,TkEVY,inUiNS,fFRTMI,ccvPZD,fDBDCY,fDcJjc,bTXZyv,hVNEqT,kWXxpK,eyrdmg,bvdCLB,hMrDZB,itSNar,etvWFx,biAQET,etpsbw,iNnJvR,jzNSzo,fvFFOw,GhgRK,iqlpQx,bOgtno,bwUkXo,hrdHBu,jHkMMn,gUQkCx,bXvGRf,cEKzMg,ciDiKz,crfreL,iTalLs,jMoSXp,eLwWzi,hwvloE,wFIQJ,eaOcSY,hoKTVY,fSbsaS,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard3&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Maskara-test: - Perfekt!\" href=\"https://www.dagbladet.no/tema/billigmaskara-testvinner-vippene-ble-lange/73131412\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Maskara-test: - Perfekt!\" alt=\"Image: Maskara-test: - Perfekt!\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73213399&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 YuxpH title dynamic-sizing\">Maskara-test:</span><span class=\"sc-226e87-0 kPzQUo title dynamic-sizing\">- Perfekt!</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=\"- Dette er bare begynnelsen\" href=\"https://www.dagbladet.no/video/-dette-er-bare-begynnelsen/QOcOmKiL\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: - Dette er bare begynnelsen\" alt=\"Image: - Dette er bare begynnelsen\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/QOcOmKiL-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 iXUXMA title dynamic-sizing\">- Dette er bare</span><span class=\"sc-226e87-0 gtTUxB title dynamic-sizing\">begynnelsen</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=\"Skal ha hatt «duell» på kontoret\" href=\"https://www.dagbladet.no/nyheter/skal-ha-hatt-duell-pa-kontoret/73322610\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Skal ha hatt «duell» på kontoret\" alt=\"Image: Skal ha hatt «duell» på kontoret\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322613&amp;panoy=47.938144329897&amp;panoh=37.113402061856&amp;panow=72.013651877133&amp;panox=13.993174061433&amp;heighty=36.842105263158&amp;heightx=31.328320802005&amp;heightw=22.556390977444&amp;heighth=55.263157894737&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jImAQx title dynamic-sizing\">Skal ha hatt</span><span class=\"sc-226e87-0 kWXIHq title dynamic-sizing\">«duell» på kontoret</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=\"Mener kronprinsessa blir mobbet på tv\" href=\"https://www.dagbladet.no/kjendis/mener-kronprinsessa-blir-mobbet-pa-tv/73321772\"><figure class=\"sc-1gprk7r-0 ryQzk\"><picture><img data-defer=\"view\" title=\"Image: Mener kronprinsessa blir mobbet på tv\" alt=\"Image: Mener kronprinsessa blir mobbet på tv\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321911&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=15.714285714286&amp;panox=0&amp;heighty=0&amp;heightx=31.221719457014&amp;heightw=40.723981900452&amp;heighth=100&amp;width=485&amp;height=274\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dkLtKc title dynamic-sizing\">Mener kronprinsessa</span><span class=\"sc-226e87-0 dIxxkx title dynamic-sizing\">blir mobbet på tv</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=\"Bryter stillheten - forklarer viralbildet\" href=\"https://www.dagbladet.no/kjendis/bryter-stillheten---forklarer-viralbildet/73320521\"><figure class=\"sc-1gprk7r-0 kVLbii\"><picture><img data-defer=\"view\" title=\"Image: Bryter stillheten - forklarer viralbildet\" alt=\"Image: Bryter stillheten - forklarer viralbildet\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320654&amp;panox=0.0053857819905148&amp;panoy=4.6153846153846&amp;panow=100.00538578199&amp;panoh=36.928904615385&amp;heighty=0.007678378378369&amp;heightx=19.375&amp;heightw=56.8821025&amp;heighth=100.00767837838&amp;width=485&amp;height=384\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dhVPLY title dynamic-sizing\">Bryter stillheten -</span><span class=\"sc-226e87-0 kWXIHq title dynamic-sizing\">forklarer viralbildet</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=\"Gir opp: - Er kjørt\" href=\"https://www.dagbladet.no/sport/gir-opp---er-kjort/73321309\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Gir opp: - Er kjørt\" alt=\"Image: Gir opp: - Er kjørt\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73145715&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;panoy=5.0724637681159&amp;heighty=0.014269863013704&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;heightx=19.634703196347&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 goyPlf title dynamic-sizing\">Gir opp:</span><span class=\"sc-226e87-0 gwXtNi title dynamic-sizing\">- Er kjørt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Verste jeg har sett!\" href=\"https://www.dagbladet.no/video/-verste-jeg-har-sett/7gneSIs4\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: - Verste jeg har sett!\" alt=\"Image: - Verste jeg har sett!\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/7gneSIs4-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 eUDXpR title dynamic-sizing\">- Verste jeg</span><span class=\"sc-226e87-0 gOMQzB title dynamic-sizing\">har sett!</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Trening hjemme: Disse er rå!\" href=\"https://www.dagbladet.no/tema/disse-er-helt-ra/73049650\"><figure class=\"sc-1gprk7r-0 lfdmgf\"><picture><img data-defer=\"view\" title=\"Image: Trening hjemme: Disse er rå!\" alt=\"Image: Trening hjemme: Disse er rå!\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73214560&amp;panox=0&amp;panoy=0&amp;panoh=100&amp;panow=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=201\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 eDBixd title dynamic-sizing\">Trening hjemme:</span><span class=\"sc-226e87-0 bfzPjL title dynamic-sizing\">Disse er rå!</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=\"Ut mot TV 2-måling: - Slett håndverk\" href=\"https://www.dagbladet.no/nyheter/ut-mot-tv-2-maling---slett-handverk/73316053\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Ut mot TV 2-måling: - Slett håndverk\" alt=\"Image: Ut mot TV 2-måling: - Slett håndverk\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73318154&amp;panow=100&amp;panoh=43.030303030303&amp;panoy=7.2727272727273&amp;panox=0&amp;heightx=16.129032258065&amp;heighty=0&amp;heightw=48.387096774194&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">Ut mot TV 2-måling:</span><span class=\"sc-226e87-0 jefjkY title dynamic-sizing\">- Slett håndverk</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=\"- Jeg var for homo\" href=\"https://www.dagbladet.no/kjendis/jeg-var-for-homo/73319144\"><figure class=\"sc-1gprk7r-0 fREbZN\"><picture><img data-defer=\"view\" title=\"Image: - Jeg var for homo\" alt=\"Image: - Jeg var for homo\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73303464&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=223\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 BSpIV title dynamic-sizing\">- Jeg var</span><span class=\"sc-226e87-0 jlGXXG title dynamic-sizing\">for homo</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=\"Tysk slakt: - Galskap\" href=\"https://www.dagbladet.no/sport/tysk-slakt---galskap/73320390\"><figure class=\"sc-1gprk7r-0 hPCeKL\"><picture><img data-defer=\"view\" title=\"Image: Tysk slakt: - Galskap\" alt=\"Image: Tysk slakt: - Galskap\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320394&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=50.729167142857&amp;panoy=12.857142857143&amp;heighty=0.014269863013704&amp;heightx=30.414746543779&amp;heightw=41.023425806452&amp;heighth=100.01426986301&amp;width=402&amp;height=267\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 kQgxdX title dynamic-sizing\">Tysk slakt:</span><span class=\"sc-226e87-0 jZAQlv title dynamic-sizing\">- Galskap</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=\"- Forakt\" href=\"https://www.dagbladet.no/nyheter/forakt/73322713\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: - Forakt\" alt=\"Image: - Forakt\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322741&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fNoJSh title dynamic-sizing\">- Forakt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard4&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Redder slange - så skjer dette\" href=\"https://www.dagbladet.no/video/redder-slange-sa-skjer-dette/2T64fyjV\"><figure class=\"sc-1gprk7r-0 fZtJip\"><picture><img data-defer=\"view\" title=\"Image: Redder slange - så skjer dette\" alt=\"Image: Redder slange - så skjer dette\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/2T64fyjV-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fLRKWS title dynamic-sizing\">Redder slange -</span><span class=\"sc-226e87-0 dYVUKX title dynamic-sizing\">så skjer dette</span></h3></header></a></article><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Alkometer-test: Vinneren imponerer\" href=\"https://www.dagbladet.no/tema/alkometer-test-vinneren-imponerende-presis/73116161\"><figure class=\"sc-1gprk7r-0 fZtJip\"><picture><img data-defer=\"view\" title=\"Image: Alkometer-test: Vinneren imponerer\" alt=\"Image: Alkometer-test: Vinneren imponerer\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73172006&amp;panoy=29.365079365079&amp;panox=0&amp;panow=100&amp;panoh=56.349206349206&amp;heightx=22.406639004149&amp;heightw=37.344398340249&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=163\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fLRKWS title dynamic-sizing\">Alkometer-test:</span><span class=\"sc-226e87-0 kEABPd title dynamic-sizing\">Vinneren imponerer</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=\"Stjerna ugjenkjennelig på nytt bilde\" href=\"https://www.dagbladet.no/kjendis/stjerna-ugjenkjennelig-pa-nytt-bilde/73322524\"><figure class=\"sc-1gprk7r-0 dauuSl\"><picture><img data-defer=\"view\" title=\"Image: Stjerna ugjenkjennelig på nytt bilde\" alt=\"Image: Stjerna ugjenkjennelig på nytt bilde\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322552&amp;panoy=43.129770992366&amp;panox=0&amp;panow=100&amp;panoh=27.099236641221&amp;heighth=100&amp;heightw=76.271186440678&amp;heighty=0&amp;heightx=23.728813559322&amp;width=485&amp;height=272\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 lmKcnW title dynamic-sizing\">Stjerna ugjenkjennelig</span><span class=\"sc-226e87-0 cONGAH title dynamic-sizing\">på nytt bilde</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=\"NRK-ekspert: - Uforståelig\" href=\"https://www.dagbladet.no/sport/nrk-ekspert---uforstaelig/73320730\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: NRK-ekspert: - Uforståelig\" alt=\"Image: NRK-ekspert: - Uforståelig\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320739&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;panoy=22.463768115942&amp;panox=0.01001634615385&amp;heighty=0.014269863013704&amp;heightx=39.269406392694&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 lbIvFp title dynamic-sizing\">NRK-ekspert:</span><span class=\"sc-226e87-0 gOMQzB title dynamic-sizing\">- Uforståelig</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=\"RBK-spiller hardt ut\" href=\"https://www.dagbladet.no/sport/rbk-spiller-hardt-ut/73320196\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: RBK-spiller hardt ut\" alt=\"Image: RBK-spiller hardt ut\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320200&amp;panow=66.248673248408&amp;panoh=33.981260287081&amp;panoy=6.2200956937799&amp;panox=31.847133757962&amp;heighty=0.014269863013704&amp;heightx=53.881278538813&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 cODKTG title dynamic-sizing\">RBK-spiller</span><span class=\"sc-226e87-0 huVjzL title dynamic-sizing\">hardt ut</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=\"Slår alarm: - Kommer til å kollapse\" href=\"https://www.dagbladet.no/nyheter/slar-alarm---kommer-til-a-kollapse/73319992\"><figure class=\"sc-1gprk7r-0 taCYg\"><picture><img data-defer=\"view\" title=\"Image: Slår alarm: - Kommer til å kollapse\" alt=\"Image: Slår alarm: - Kommer til å kollapse\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320012&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=314\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gvivVM title dynamic-sizing\">Slår alarm:</span><span class=\"sc-226e87-0 tTqiK title dynamic-sizing\">- Kommer til</span><span class=\"sc-226e87-0 cONGAH title dynamic-sizing\">å kollapse</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=\"Billig oppvaskmaskin-triks\" href=\"https://www.dagbladet.no/video/billig-oppvaskmaskin-triks/m1dO04wU\"><figure class=\"sc-1gprk7r-0 blDduk\"><picture><img data-defer=\"view\" title=\"Image: Billig oppvaskmaskin-triks\" alt=\"Image: Billig oppvaskmaskin-triks\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/m1dO04wU-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fcOaLE title dynamic-sizing\">Billig oppvaskmaskin-triks</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=\"Angstfri på fire dager\" href=\"https://www.dagbladet.no/tema/kristian-23-ble-kvitt-angsten-pa-fire-dager/73161004\"><figure class=\"sc-1gprk7r-0 elXDbt\"><picture><img data-defer=\"view\" title=\"Image: Angstfri på fire dager\" alt=\"Image: Angstfri på fire dager\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73229211&amp;panox=0&amp;panow=100&amp;panoh=30.769230769231&amp;panoy=11.111111111111&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=238\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 kVyWiO title dynamic-sizing\">Angstfri på</span><span class=\"sc-226e87-0 impgzW title dynamic-sizing\">fire dager</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gjør et jakkekupp nå\" href=\"https://www.dagbladet.no/annonse/dunjakker-for-kalde-dager/72977308\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/03/20/allerlogo.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Gjør et jakkekupp nå\" alt=\"Image: Gjør et jakkekupp nå\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/72981305.jpg?imageId=72981305&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=65.346535&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 hoeVhK title dynamic-sizing\">Gjør et</span><span class=\"sc-226e87-0 gyclYO title dynamic-sizing\">jakkekupp nå</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Syk av flåttbitt: - Lav energi\" href=\"https://www.dagbladet.no/kjendis/syk-av-flattbitt---lav-energi/73312436\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Syk av flåttbitt: - Lav energi\" alt=\"Image: Syk av flåttbitt: - Lav energi\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73317688&amp;panoy=17.931034482759&amp;panox=0&amp;panow=99.770642201835&amp;panoh=50.689655172414&amp;heightw=40.570175438596&amp;heighth=100.33112582781&amp;heighty=0&amp;heightx=35.526315789474&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 DJrhN title dynamic-sizing\">Syk av flåttbitt:</span><span class=\"sc-226e87-0 fnTXOy title dynamic-sizing\">- Lav energi</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Kampen kan bli langt hardere\" href=\"https://www.dagbladet.no/meninger/ny-pest-i-en-pagaende-pandemi/73315621\"><figure class=\"sc-1gprk7r-0 knzTC\"><picture><img data-defer=\"view\" title=\"Image: Kampen kan bli langt hardere\" alt=\"Image: Kampen kan bli langt hardere\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73319577&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=253\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jUorVM title dynamic-sizing\">Kampen kan bli</span><span class=\"sc-226e87-0 lbIvFp title dynamic-sizing\">langt hardere</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Tida renner ut\" href=\"https://www.dagbladet.no/kjendis/tida-renner-ut/73320029\"><figure class=\"sc-1gprk7r-0 tXCDm\"><picture><img data-defer=\"view\" title=\"Image: - Tida renner ut\" alt=\"Image: - Tida renner ut\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320032&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=59.504132231405&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=334\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 irCLxI title dynamic-sizing\">- Tida renner ut</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=\"Grove anklager mot Norge\" href=\"https://www.dagbladet.no/sport/grove-anklager-mot-norge/73321280\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Grove anklager mot Norge\" alt=\"Image: Grove anklager mot Norge\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321374&amp;panoy=8.5106382978723&amp;panox=0&amp;panow=81.395348837209&amp;panoh=75.531914893617&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;heightx=19.457013574661&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 tTqiK title dynamic-sizing\">Grove anklager</span><span class=\"sc-226e87-0 kihcRj title dynamic-sizing\">mot Norge</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard5&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Røkkes nye børskomet: Ekspertenes råd\" href=\"https://www.dagbladet.no/tema/rokkes-nye-borskomet-ekspertenes-rad/73252348\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Røkkes nye børskomet: Ekspertenes råd\" alt=\"Image: Røkkes nye børskomet: Ekspertenes råd\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73254849&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighty=0&amp;heightw=40.540540540541&amp;heighth=100&amp;heightx=20.720720720721&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 eOrgrB title dynamic-sizing\">Røkkes nye børskomet:</span><span class=\"sc-226e87-0 fLRKWS title dynamic-sizing\">Ekspertenes råd</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=\"Kjempehaien går viralt: - Herregud!\" href=\"https://www.dagbladet.no/video/kjempehaien-gar-viralt-herregud/1uvFG247\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Kjempehaien går viralt: - Herregud!\" alt=\"Image: Kjempehaien går viralt: - Herregud!\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/1uvFG247-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gyclYO title dynamic-sizing\">Kjempehaien</span><span class=\"sc-226e87-0 kPzQUo title dynamic-sizing\">går viralt:</span><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">- Herregud!</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=\"Reagerer: - Svakt\" href=\"https://www.dagbladet.no/sport/reagerer---svakt/73323061\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Reagerer: - Svakt\" alt=\"Image: Reagerer: - Svakt\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73323065&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;panox=0.01001634615385&amp;panoy=10.144927536232&amp;heightx=29.680365296804&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;heighty=0.014269863013704&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dIUEjq title dynamic-sizing\">Reagerer:</span><span class=\"sc-226e87-0 dzspVx title dynamic-sizing\">- Svakt</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=\"- Klar for Arsenal\" href=\"https://www.dagbladet.no/sport/klar-for-arsenal/73323691\"><figure class=\"sc-1gprk7r-0 fTBjDc\"><picture><img data-defer=\"view\" title=\"Image: - Klar for Arsenal\" alt=\"Image: - Klar for Arsenal\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73323698&amp;panoy=5.3763440860215&amp;panox=14.788732394366&amp;panow=74.299776056338&amp;panoh=38.715787096774&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=369\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jlGXXG title dynamic-sizing\">- Klar for</span><span class=\"sc-226e87-0 djJIro title dynamic-sizing\">Arsenal</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=\"Dette er regjeringens nye tiltak\" href=\"https://www.dagbladet.no/nyheter/dette-er-regjeringens-nye-tiltak/73320211\"><figure class=\"sc-1gprk7r-0 htYqxw\"><picture><img data-defer=\"view\" title=\"Image: Dette er regjeringens nye tiltak\" alt=\"Image: Dette er regjeringens nye tiltak\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320226&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=359\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 BsdKn title dynamic-sizing\">Dette er regjeringens</span><span class=\"sc-226e87-0 eycHRp title dynamic-sizing\">nye tiltak</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=\"Svarer på hytte-kritikken\" href=\"https://www.dagbladet.no/nyheter/svarer-pa-hytte-kritikken/73322395\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Svarer på hytte-kritikken\" alt=\"Image: Svarer på hytte-kritikken\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321234&amp;panox=0&amp;panoy=7.6271186440678&amp;panow=100&amp;panoh=60.169491525424&amp;heightw=100&amp;heighty=0&amp;heightx=0&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dEDsKr title dynamic-sizing\">Svarer på</span><span class=\"sc-226e87-0 eEIScg title dynamic-sizing\">hytte-kritikken</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=\"«Hånes» etter nytt stunt\" href=\"https://www.dagbladet.no/video/hanes-etter-nytt-stunt/iNAOV1SL\"><figure class=\"sc-1gprk7r-0 dcXyHK\"><picture><img data-defer=\"view\" title=\"Image: «Hånes» etter nytt stunt\" alt=\"Image: «Hånes» etter nytt stunt\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/iNAOV1SL-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 YuxpH title dynamic-sizing\">«Hånes» etter</span><span class=\"sc-226e87-0 kPzQUo title dynamic-sizing\">nytt stunt</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=\"Rimelig bil vant stor vintertest\" href=\"https://www.dagbladet.no/tema/rimelig-bil-vant-stor-vintertest/73193571\"><figure class=\"sc-1gprk7r-0 eMBUIR\"><picture><img data-defer=\"view\" title=\"Image: Rimelig bil vant stor vintertest\" alt=\"Image: Rimelig bil vant stor vintertest\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73201510&amp;panow=81.395348837209&amp;panoh=39.226519337017&amp;panoy=35.911602209945&amp;panox=8.9147286821705&amp;heighty=21.893214285714&amp;heightx=32.065485893417&amp;heightw=29.467084639498&amp;heighth=68.303571428571&amp;width=320&amp;height=226\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jcwTZx title dynamic-sizing\">Rimelig bil vant</span><span class=\"sc-226e87-0 YuxpH title dynamic-sizing\">stor vintertest</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nå er det salg på vintersko\" href=\"https://www.dagbladet.no/annonse/gjor-et-kupp-pa-vintersko-na/72970436\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/03/20/allerlogo.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Nå er det salg på vintersko\" alt=\"Image: Nå er det salg på vintersko\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/73071813.jpg?imageId=73071813&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=100.000000&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dYVUKX title dynamic-sizing\">Nå er det salg</span><span class=\"sc-226e87-0 bSTtWv title dynamic-sizing\">på vintersko</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slett håndverk av TV 2\" href=\"https://www.dagbladet.no/meninger/i-strid-med-fakta/73314072\"><figure class=\"sc-1gprk7r-0 jnPmsV\"><picture><img data-defer=\"view\" title=\"Image: Slett håndverk av TV 2\" alt=\"Image: Slett håndverk av TV 2\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73316503&amp;panoy=17.735849056604&amp;panox=9.0680100755668&amp;panow=52.26654120603&amp;panoh=26.800314716981&amp;heighty=2.7027027027027&amp;heightw=64.978710948905&amp;heighth=66.072775565611&amp;heightx=12.408759124088&amp;width=402&amp;height=247\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dhVPLY title dynamic-sizing\">Slett håndverk</span><span class=\"sc-226e87-0 efqLUy title dynamic-sizing\">av TV 2</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=\"«Farmen»-profilen røper gravidnyhet\" href=\"https://www.dagbladet.no/kjendis/farmen-profilen-roper-gravidnyhet/73321230\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: «Farmen»-profilen røper gravidnyhet\" alt=\"Image: «Farmen»-profilen røper gravidnyhet\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321370&amp;panow=100&amp;panoy=11.877394636015&amp;panoh=27.2030651341&amp;panox=0&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jUorVM title dynamic-sizing\">«Farmen»-profilen</span><span class=\"sc-226e87-0 tTqiK title dynamic-sizing\">røper gravidnyhet</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=\"NRK lurte svenskene\" href=\"https://www.dagbladet.no/sport/nrk-lurte-svenskene/73319973\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: NRK lurte svenskene\" alt=\"Image: NRK lurte svenskene\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320688&amp;panoy=14&amp;panox=14.583333333333&amp;panow=73.263888888889&amp;panoh=72&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 cTGhck title dynamic-sizing\">NRK lurte</span><span class=\"sc-226e87-0 jkEAqG title dynamic-sizing\">svenskene</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=\"Grove trusler fra Polen\" href=\"https://www.dagbladet.no/sport/grove-trusler-fra-polen/73318529\"><figure class=\"sc-1gprk7r-0 kBBPoW\"><picture><img data-defer=\"view\" title=\"Image: Grove trusler fra Polen\" alt=\"Image: Grove trusler fra Polen\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73240211&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;panoy=26.811594202899&amp;heightw=40.280920361991&amp;heighth=100.01426986301&amp;heightx=22.62443438914&amp;heighty=0.014269863013704&amp;width=402&amp;height=364\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 ZDmxx title dynamic-sizing\">Grove trusler</span><span class=\"sc-226e87-0 jlGXXG title dynamic-sizing\">fra Polen</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-12 medium-12 large-12 \" data-from=\"xavier\"><div id=\"ad-smartbanner1\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600], [980,300], [970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;smartbanner1&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Vi anmeldte «Hver gang vi møtes» låt for låt\" href=\"https://www.dagbladet.no/kultur/vi-anmeldte-hver-gang-vi-motes-lat-for-lat/73321376\"><figure class=\"sc-1gprk7r-0 hlMjpg\"><picture><img data-defer=\"view\" title=\"Image: Vi anmeldte «Hver gang vi møtes» låt for låt\" alt=\"Image: Vi anmeldte «Hver gang vi møtes» låt for låt\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321479&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=485&amp;height=259\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jcwTZx title dynamic-sizing\">Vi anmeldte «Hver gang</span><span class=\"sc-226e87-0 kWXIHq title dynamic-sizing\">vi møtes» låt for låt</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=\"Utsatt for innbrudd - trygler om hjelp\" href=\"https://www.dagbladet.no/kjendis/utsatt-for-innbrudd---trygler-om-hjelp/73319387\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Utsatt for innbrudd - trygler om hjelp\" alt=\"Image: Utsatt for innbrudd - trygler om hjelp\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73319407&amp;panoy=11.834319526627&amp;panox=0&amp;panow=100&amp;panoh=42.011834319527&amp;heightx=43.169398907104&amp;heightw=49.180327868852&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 bSTtWv title dynamic-sizing\">Utsatt for innbrudd</span><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">- trygler om hjelp</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=\"Norsk støtte til svensk sjokkgrep\" href=\"https://www.dagbladet.no/nyheter/norsk-stotte-til-svensk-sjokkgrep/73322006\"><figure class=\"sc-1gprk7r-0 dmTTiz\"><picture><img data-defer=\"view\" title=\"Image: Norsk støtte til svensk sjokkgrep\" alt=\"Image: Norsk støtte til svensk sjokkgrep\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322251&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=402&amp;height=316\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dhVPLY title dynamic-sizing\">Norsk støtte til</span><span class=\"sc-226e87-0 dkLtKc title dynamic-sizing\">svensk sjokkgrep</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=\"Sverige: Etterregistrerte 1235 dødsfall\" href=\"https://www.dagbladet.no/nyheter/sverige-etterregistrerte-1235-dodsfall/73315667\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Sverige: Etterregistrerte 1235 dødsfall\" alt=\"Image: Sverige: Etterregistrerte 1235 dødsfall\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73315362&amp;panow=100&amp;panoh=50.714285714286&amp;panox=0&amp;panoy=22.857142857143&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dYVUKX title dynamic-sizing\">Sverige: Etterregistrerte</span><span class=\"sc-226e87-0 TkEVY title dynamic-sizing\">1235 dødsfall</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=\"Iskaffe: Slik unngås kalori-bombene\" href=\"https://www.dagbladet.no/tema/iskaffe-slik-unngas-kalori-bombene/73169154\"><figure class=\"sc-1gprk7r-0 jJclyb\"><picture><img data-defer=\"view\" title=\"Image: Iskaffe: Slik unngås kalori-bombene\" alt=\"Image: Iskaffe: Slik unngås kalori-bombene\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73213290&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=223\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 kEABPd title dynamic-sizing\">Iskaffe: Slik unngås</span><span class=\"sc-226e87-0 fLRKWS title dynamic-sizing\">kalori-bombene</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=\"Skikkelsen angriper \" href=\"https://www.dagbladet.no/video/skikkelsen-angriper-/YCosDYz6\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Skikkelsen angriper \" alt=\"Image: Skikkelsen angriper \" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/YCosDYz6-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 inUiNS title dynamic-sizing\">Skikkelsen</span><span class=\"sc-226e87-0 fFRTMI title dynamic-sizing\">angriper </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=\"Seier - slik sikrer Norge kvartfinale\" href=\"https://www.dagbladet.no/sport/seier---slik-sikrer-norge-kvartfinale/73319510\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Seier - slik sikrer Norge kvartfinale\" alt=\"Image: Seier - slik sikrer Norge kvartfinale\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73319743&amp;panow=99.893163461538&amp;panoh=49.487787234043&amp;panoy=9.2198581560284&amp;panox=0&amp;heightx=22.169811320755&amp;heightw=41.876311320755&amp;heighth=100.540125&amp;heighty=0.540125&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">Seier - slik sikrer</span><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">Norge kvartfinale</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 livredd dommen\" href=\"https://www.dagbladet.no/kultur/var-livredd-dommen/73315743\"><figure class=\"sc-1gprk7r-0 OIImT\"><picture><img data-defer=\"view\" title=\"Image: Var livredd dommen\" alt=\"Image: Var livredd dommen\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73315881&amp;panox=0&amp;panoy=43.809523809524&amp;panow=100&amp;panoh=22.539682539683&amp;heighty=35.620052770449&amp;heightx=29.2&amp;heightw=36&amp;heighth=38.786279683377&amp;width=485&amp;height=310\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gyclYO title dynamic-sizing\">Var livredd dommen</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=\"Raser mot russer\" href=\"https://www.dagbladet.no/sport/raser-mot-russer/73321002\"><figure class=\"sc-1gprk7r-0 bmkgwI\"><picture><img data-defer=\"view\" title=\"Image: Raser mot russer\" alt=\"Image: Raser mot russer\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321008&amp;panoy=29.710144927536&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;heighty=0.014269863013704&amp;heightx=26.48401826484&amp;width=485&amp;height=474\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 kVyWiO title dynamic-sizing\">Raser mot russer</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=\"Slo vilt - disket\" href=\"https://www.dagbladet.no/sport/slo-vilt---disket/73323222\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Slo vilt - disket\" alt=\"Image: Slo vilt - disket\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73323207&amp;panoy=12.31884057971&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;heighty=0.014269863013704&amp;heightx=31.506849315068&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 ccvPZD title dynamic-sizing\">Slo vilt</span><span class=\"sc-226e87-0 fDBDCY title dynamic-sizing\">- disket</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard6&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Ekle bilder!\" href=\"https://www.dagbladet.no/video/-ekle-bilder/6vsQ5ufd\"><figure class=\"sc-1gprk7r-0 dzEIYn\"><picture><img data-defer=\"view\" title=\"Image: - Ekle bilder!\" alt=\"Image: - Ekle bilder!\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/6vsQ5ufd-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gtTUxB title dynamic-sizing\">- Ekle bilder!</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=\"Hellstrøm-pizza: - Klar vinner\" href=\"https://www.dagbladet.no/mat/test-av-hellstrom-pizza-klar-vinner/73312241\"><figure class=\"sc-1gprk7r-0 dzEIYn\"><picture><img data-defer=\"view\" title=\"Image: Hellstrøm-pizza: - Klar vinner\" alt=\"Image: Hellstrøm-pizza: - Klar vinner\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73313240&amp;panoy=19.323671497585&amp;panox=0&amp;panow=100&amp;panoh=35.748792270531&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 BsdKn title dynamic-sizing\">Hellstrøm-pizza:</span><span class=\"sc-226e87-0 bSTtWv title dynamic-sizing\">- Klar vinner</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=\"Risikerer operasjon: - Fikk sjokk\" href=\"https://www.dagbladet.no/kjendis/risikerer-operasjon---fikk-sjokk/73306972\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Risikerer operasjon: - Fikk sjokk\" alt=\"Image: Risikerer operasjon: - Fikk sjokk\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73307452&amp;panow=76.756536764706&amp;panoh=16.536864485981&amp;panoy=3.5046728971963&amp;panox=11.397058823529&amp;heighty=2.974828375286&amp;heightx=33.333333333333&amp;heightw=32.765613138686&amp;heighth=33.435270642202&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">Risikerer operasjon:</span><span class=\"sc-226e87-0 fDcJjc title dynamic-sizing\">- Fikk sjokk</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=\"Nye tiltak for skoler og barnehager\" href=\"https://www.dagbladet.no/nyheter/nye-tiltak-for-skoler-og-barnehager/73323115\"><figure class=\"sc-1gprk7r-0 dsCdew\"><picture><img data-defer=\"view\" title=\"Image: Nye tiltak for skoler og barnehager\" alt=\"Image: Nye tiltak for skoler og barnehager\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73323138&amp;panoh=50.714285714286&amp;panoy=7.1428571428571&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=204\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jZAQlv title dynamic-sizing\">Nye tiltak</span><span class=\"sc-226e87-0 TkEVY title dynamic-sizing\">for skoler</span><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">og barnehager</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=\"Skaper full forvirring med gjenforening\" href=\"https://www.dagbladet.no/kjendis/skaper-full-forvirring-med-gjenforening/73322188\"><figure class=\"sc-1gprk7r-0 fCgDzX\"><picture><img data-defer=\"view\" title=\"Image: Skaper full forvirring med gjenforening\" alt=\"Image: Skaper full forvirring med gjenforening\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322248&amp;panoh=33.809523809524&amp;panoy=3.8095238095238&amp;panox=0&amp;panow=100&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=228\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gvivVM title dynamic-sizing\">Skaper full</span><span class=\"sc-226e87-0 ivfiEr title dynamic-sizing\">forvirring med</span><span class=\"sc-226e87-0 DJrhN title dynamic-sizing\">gjenforening</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=\"Røper hemmelig sykdomsdrama\" href=\"https://www.dagbladet.no/kjendis/roper-hemmelig-sykdomsdrama/73314691\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Røper hemmelig sykdomsdrama\" alt=\"Image: Røper hemmelig sykdomsdrama\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73314697&amp;panoy=31.395348837209&amp;panox=15.891472868217&amp;panow=81.395348837209&amp;panoh=41.279069767442&amp;heightw=30.30303030303&amp;heighth=74.242424242424&amp;heighty=20.707070707071&amp;heightx=36.700336700337&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 bTXZyv title dynamic-sizing\">Røper hemmelig</span><span class=\"sc-226e87-0 hVNEqT title dynamic-sizing\">sykdomsdrama</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=\"Slakter kongressmedlemmer: - Hva i helvete\" href=\"https://www.dagbladet.no/video/slakter-kongressmedlemmer-hva-i-helvete/iquv0Pdt\"><figure class=\"sc-1gprk7r-0 jULjqn\"><picture><img data-defer=\"view\" title=\"Image: Slakter kongressmedlemmer: - Hva i helvete\" alt=\"Image: Slakter kongressmedlemmer: - Hva i helvete\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/iquv0Pdt-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 kWXxpK title dynamic-sizing\">Slakter kongressmedlemmer:</span><span class=\"sc-226e87-0 iXUXMA title dynamic-sizing\">- Hva i helvete</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=\"Pillene som raskest senker blodtrykket\" href=\"https://www.dagbladet.no/tema/pillene-som-raskest-senker-blodtrykket/73181589\"><figure class=\"sc-1gprk7r-0 hSyFSz\"><picture><img data-defer=\"view\" title=\"Image: Pillene som raskest senker blodtrykket\" alt=\"Image: Pillene som raskest senker blodtrykket\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73181591&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;heighty=0&amp;width=320&amp;height=276\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 kEABPd title dynamic-sizing\">Pillene som raskest</span><span class=\"sc-226e87-0 eyrdmg title dynamic-sizing\">senker blodtrykket</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 native-advertisement\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nettkurs i 5:2 dietten\" href=\"https://www.dagbladet.no/kurs/periodisk-faste---online-kurs/73069416\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2020/03/20/allerlogo.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Nettkurs i 5:2 dietten\" alt=\"Image: Nettkurs i 5:2 dietten\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/73087365.jpg?imageId=73087365&amp;x=35.006784&amp;y=17.864476&amp;cropw=29.579376&amp;croph=15.195072&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 tTqiK title dynamic-sizing\">Nettkurs i</span><span class=\"sc-226e87-0 bvdCLB title dynamic-sizing\">5:2 dietten</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Brutalt ærlig på TV\" href=\"https://www.dagbladet.no/sport/brutalt-aerlig-pa-tv/73312977\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Brutalt ærlig på TV\" alt=\"Image: Brutalt ærlig på TV\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73314927&amp;panoy=21.835443037975&amp;panox=0&amp;panow=100&amp;panoh=22.46835443038&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fNoJSh title dynamic-sizing\">Brutalt</span><span class=\"sc-226e87-0 TkEVY title dynamic-sizing\">ærlig på TV</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=\"Nedslående beskjed til Oslo\" href=\"https://www.dagbladet.no/nyheter/nedslaende-beskjed-til-oslo/73318861\"><figure class=\"sc-1gprk7r-0 cLImwa\"><picture><img data-defer=\"view\" title=\"Image: Nedslående beskjed til Oslo\" alt=\"Image: Nedslående beskjed til Oslo\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320727&amp;panoy=6.3218390804598&amp;panox=0&amp;panow=100&amp;panoh=40.804597701149&amp;heightw=50.847457627119&amp;heighth=100&amp;heighty=0&amp;heightx=23.16384180791&amp;width=485&amp;height=331\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jImAQx title dynamic-sizing\">Nedslående</span><span class=\"sc-226e87-0 DJrhN title dynamic-sizing\">beskjed til Oslo</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=\"Hunden ventet seks dager utenfor sykehuset\" href=\"https://www.dagbladet.no/nyheter/hunden-ventet-seks-dager-utenfor-sykehuset/73320182\"><figure class=\"sc-1gprk7r-0 dmTTiz\"><picture><img data-defer=\"view\" title=\"Image: Hunden ventet seks dager utenfor sykehuset\" alt=\"Image: Hunden ventet seks dager utenfor sykehuset\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73320661&amp;panoy=18.543046357616&amp;panox=0&amp;panow=100&amp;panoh=49.006622516556&amp;heighty=0&amp;heightw=42.533936651584&amp;heighth=100&amp;heightx=10.407239819005&amp;width=402&amp;height=316\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jcwTZx title dynamic-sizing\">Hunden ventet seks</span><span class=\"sc-226e87-0 kEABPd title dynamic-sizing\">dager utenfor sykehuset</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=\"Brente statsminister-dokke: «Hun må avlives»\" href=\"https://www.dagbladet.no/nyheter/brente-statsminister-dokke-hun-ma-avlives/73322737\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Brente statsminister-dokke: «Hun må avlives»\" alt=\"Image: Brente statsminister-dokke: «Hun må avlives»\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322854&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightw=40.723752293578&amp;heighth=100.540125&amp;heighty=0.540125&amp;heightx=44.036697247706&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fLRKWS title dynamic-sizing\">Brente statsminister-dokke:</span><span class=\"sc-226e87-0 hMrDZB title dynamic-sizing\">«Hun må avlives»</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard7&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Mesternes mester-profilens alvorlige ulykke\" href=\"https://www.dagbladet.no/sport/alvorlig-ulykke-for-tidenes-yngste-i-mesternes-mester/73191907\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Mesternes mester-profilens alvorlige ulykke\" alt=\"Image: Mesternes mester-profilens alvorlige ulykke\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73191975&amp;panoy=23.001394335512&amp;panox=18.604651162791&amp;panow=81.395348837209&amp;panoh=15.468409586057&amp;heightx=0&amp;heighty=0&amp;heightw=100&amp;heighth=91.875&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 itSNar title dynamic-sizing\">Mesternes mester-profilens</span><span class=\"sc-226e87-0 fLRKWS title dynamic-sizing\">alvorlige ulykke</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=\"Vekker oppsikt i Italia\" href=\"https://www.dagbladet.no/video/vekker-oppsikt-i-italia/sVb03A4z\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Vekker oppsikt i Italia\" alt=\"Image: Vekker oppsikt i Italia\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/sVb03A4z-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 lmKcnW title dynamic-sizing\">Vekker oppsikt</span><span class=\"sc-226e87-0 etvWFx title dynamic-sizing\">i Italia</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører ny jobb\" href=\"https://www.dagbladet.no/kjendis/avslorer-ny-jobb/73323328\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: Avslører ny jobb\" alt=\"Image: Avslører ny jobb\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73323343&amp;panox=0&amp;panow=88.66023697479&amp;panoh=45.576812658228&amp;panoy=3.1645569620253&amp;heighty=0.007678378378369&amp;heightx=25.225225225225&amp;heightw=40.99610990991&amp;heighth=100.00767837838&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 biAQET title dynamic-sizing\">Avslører</span><span class=\"sc-226e87-0 etpsbw title dynamic-sizing\">ny jobb</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=\"149 smittet i stort smitteutbrudd\" href=\"https://www.dagbladet.no/nyheter/149-smittet-i-stort-smitteutbrudd/73322027\"><figure class=\"sc-1gprk7r-0 dLMKhl\"><picture><img data-defer=\"view\" title=\"Image: 149 smittet i stort smitteutbrudd\" alt=\"Image: 149 smittet i stort smitteutbrudd\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322043&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=376\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 eEIScg title dynamic-sizing\">149 smittet i</span><span class=\"sc-226e87-0 kWXIHq title dynamic-sizing\">stort smitteutbrudd</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=\"- Hadde aldri gjort det der\" href=\"https://www.dagbladet.no/video/-hadde-aldri-gjort-det-der/GvdN88r4\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: - Hadde aldri gjort det der\" alt=\"Image: - Hadde aldri gjort det der\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/GvdN88r4-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gtTUxB title dynamic-sizing\">- Hadde aldri</span><span class=\"sc-226e87-0 bSTtWv title dynamic-sizing\">gjort det der</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=\"Øde Nerdrum om mobbingen\" href=\"https://www.dagbladet.no/tema/ode-nerdrum---status-a-ha-blitt-mobbet/73301089\"><figure class=\"sc-1gprk7r-0 gHjwGX\"><picture><img data-defer=\"view\" title=\"Image: Øde Nerdrum om mobbingen\" alt=\"Image: Øde Nerdrum om mobbingen\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73301242&amp;panoy=37.80487804878&amp;panox=33.496161898116&amp;panow=14.654570830426&amp;panoh=6.7542213883677&amp;heightw=5.030743432085&amp;heighth=11.186696900983&amp;heighty=36.961451247166&amp;heightx=38.06595863611&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 iNnJvR title dynamic-sizing\">Øde Nerdrum</span><span class=\"sc-226e87-0 jzNSzo title dynamic-sizing\">om mobbingen</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle5\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle5&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7 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=\"Høie reiser fra hytta\" href=\"https://www.dagbladet.no/nyheter/hoie-reiser-fra-hytta/73321172\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Høie reiser fra hytta\" alt=\"Image: Høie reiser fra hytta\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321234&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fvFFOw title dynamic-sizing\">Høie reiser</span><span class=\"sc-226e87-0 GhgRK title dynamic-sizing\">fra hytta</span></h3></header></a></article><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=\"Anklager eksmannen for mishandling\" href=\"https://www.dagbladet.no/kjendis/anklager-eksmannen-for-mishandling/73314239\"><figure class=\"sc-1gprk7r-0 bnFcMN\"><picture><img data-defer=\"view\" title=\"Image: Anklager eksmannen for mishandling\" alt=\"Image: Anklager eksmannen for mishandling\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73314360&amp;panow=74.468085106383&amp;panoh=36.979166666667&amp;panoy=0&amp;panox=12.41134751773&amp;heighty=0&amp;heightx=31.25&amp;heightw=33.088235294118&amp;heighth=79.032258064516&amp;width=402&amp;height=441\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 iqlpQx title dynamic-sizing\">Anklager eksmannen</span><span class=\"sc-226e87-0 bOgtno title dynamic-sizing\">for mishandling</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard8&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Test: Velg riktig pulk\" href=\"https://www.dagbladet.no/tema/hvilken-barnepulk-er-best/73159733\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Test: Velg riktig pulk\" alt=\"Image: Test: Velg riktig pulk\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73167336&amp;panow=100&amp;panoh=49.65034965035&amp;panoy=9.7902097902098&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=26.88679245283&amp;heightw=42.452830188679&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 bwUkXo title dynamic-sizing\">Test: Velg</span><span class=\"sc-226e87-0 bwUkXo title dynamic-sizing\">riktig pulk</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=\"Dramatisk i New York\" href=\"https://www.dagbladet.no/video/dramatisk-i-new-york/4lWNltco\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Dramatisk i New York\" alt=\"Image: Dramatisk i New York\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/4lWNltco-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 bwUkXo title dynamic-sizing\">Dramatisk</span><span class=\"sc-226e87-0 hrdHBu title dynamic-sizing\">i New York</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"«Drukner» - løper for å hjelpe\" href=\"https://www.dagbladet.no/video/drukner-loper-for-a-hjelpe/6v1TpLli\"><figure class=\"sc-1gprk7r-0 cmoThx\"><picture><img data-defer=\"view\" title=\"Image: «Drukner» - løper for å hjelpe\" alt=\"Image: «Drukner» - løper for å hjelpe\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/6v1TpLli-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 eDBixd title dynamic-sizing\">«Drukner» - løper</span><span class=\"sc-226e87-0 kVyWiO title dynamic-sizing\">for å hjelpe</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=\"Tinder-sex? Slik lykkes du\" href=\"https://www.dagbladet.no/tema/tinder-sex-slik-lykkes-du/73214325\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Tinder-sex? Slik lykkes du\" alt=\"Image: Tinder-sex? Slik lykkes du\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=66929480&amp;panow=99.893163461538&amp;panoh=52.464496240602&amp;panoy=21.052631578947&amp;panox=0.10683653846154&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jHkMMn title dynamic-sizing\">Tinder-sex?</span><span class=\"sc-226e87-0 YuxpH title dynamic-sizing\">Slik lykkes du</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle6\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle6&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Politisk korrupsjon\" href=\"https://www.dagbladet.no/nyheter/politisk-korrupsjon/73305395\"><figure class=\"sc-1gprk7r-0 cVlffi\"><picture><img data-defer=\"view\" title=\"Image: - Politisk korrupsjon\" alt=\"Image: - Politisk korrupsjon\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73305628&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jkEAqG title dynamic-sizing\">- Politisk</span><span class=\"sc-226e87-0 gUQkCx title dynamic-sizing\">korrupsjon</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=\"Til finalen med sexy show\" href=\"https://www.dagbladet.no/kultur/til-finalen-med-sexy-show/73319913\"><figure class=\"sc-1gprk7r-0 HqEmi\"><picture><img data-defer=\"view\" title=\"Image: Til finalen med sexy show\" alt=\"Image: Til finalen med sexy show\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73321843&amp;panow=67.647058823529&amp;panoy=0&amp;panoh=66.981132075472&amp;panox=22.222222222222&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=282\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 bXvGRf title dynamic-sizing\">Til finalen</span><span class=\"sc-226e87-0 DJrhN title dynamic-sizing\">med sexy show</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Droppet alkoholen etter voldsepisode\" href=\"https://www.dagbladet.no/magasinet/droppet-alkoholen-etter-voldsepisode/73259819\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Droppet alkoholen etter voldsepisode\" alt=\"Image: Droppet alkoholen etter voldsepisode\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73259896&amp;panoy=13.414634146341&amp;panox=30.540540540541&amp;panow=56.910569105691&amp;panoh=29.268292682927&amp;heighty=12.096774193548&amp;heightw=16.187050359712&amp;heighth=39.784946236559&amp;heightx=50.179856115108&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 cEKzMg title dynamic-sizing\">Droppet alkoholen</span><span class=\"sc-226e87-0 ciDiKz title dynamic-sizing\">etter voldsepisode</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=\"- Helt jævlig\" href=\"https://www.dagbladet.no/video/-helt-jaevlig/uHiSYKV1\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: - Helt jævlig\" alt=\"Image: - Helt jævlig\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uHiSYKV1-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 bSTtWv title dynamic-sizing\">- Helt jævlig</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=\"Egne corona-råd for skianleggene\" href=\"https://www.dagbladet.no/nyheter/egne-corona-rad-for-skianleggene/73322920\"><figure class=\"sc-1gprk7r-0 llqYGt\"><picture><img data-defer=\"view\" title=\"Image: Egne corona-råd for skianleggene\" alt=\"Image: Egne corona-råd for skianleggene\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73322932&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=251\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gyclYO title dynamic-sizing\">Egne corona-råd</span><span class=\"sc-226e87-0 gyclYO title dynamic-sizing\">for skianleggene</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=\"Norsk hoppsjokk\" href=\"https://www.dagbladet.no/sport/norsk-hoppsjokk/73323657\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Norsk hoppsjokk\" alt=\"Image: Norsk hoppsjokk\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73323645&amp;panox=0.01001634615385&amp;panow=100.01001634615&amp;panoh=51.464372463768&amp;panoy=7.9710144927536&amp;heighty=0.014269863013704&amp;heightx=19.634703196347&amp;heightw=40.648782648402&amp;heighth=100.01426986301&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 crfreL title dynamic-sizing\">Norsk hoppsjokk</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=\"Bekrefter comeback\" href=\"https://www.dagbladet.no/video/bekrefter-comeback/34z0zVWI\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Bekrefter comeback\" alt=\"Image: Bekrefter comeback\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/34z0zVWI-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 crfreL title dynamic-sizing\">Bekrefter</span><span class=\"sc-226e87-0 bwUkXo title dynamic-sizing\">comeback</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=\"Det beste på tv: - Suveren\" href=\"https://www.dagbladet.no/kultur/karing-tv-seriene-du-ma-se/73157433\"><figure class=\"sc-1gprk7r-0 jsBxvK\"><picture><img data-defer=\"view\" title=\"Image: Det beste på tv: - Suveren\" alt=\"Image: Det beste på tv: - Suveren\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73167223&amp;panoy=8&amp;panox=0&amp;panow=100&amp;panoh=47.333333333333&amp;heighty=0&amp;heightx=19.211822660099&amp;heightw=44.334975369458&amp;heighth=100&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 iTalLs title dynamic-sizing\">Det beste på</span><span class=\"sc-226e87-0 gtTUxB title dynamic-sizing\">tv: - Suveren</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle7\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle7&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"general-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Erna knuses av viruset\" href=\"https://www.dagbladet.no/kultur/erna-knuses-av-viruset/73317490\"><figure class=\"sc-1gprk7r-0 LNrJj\"><picture><img data-defer=\"view\" title=\"Image: Erna knuses av viruset\" alt=\"Image: Erna knuses av viruset\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73317559&amp;panow=65.94105125&amp;panoy=9.8989898989899&amp;panoh=14.54775030303&amp;panox=33.7465625&amp;heightw=78.458072413793&amp;heighth=81.324925274725&amp;heightx=1.7241379310345&amp;heighty=3.2967032967033&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 jMoSXp title dynamic-sizing\">Erna knuses</span><span class=\"sc-226e87-0 eLwWzi title dynamic-sizing\">av viruset</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=\"Tvunget til å hvile i parkeringshus\" href=\"https://www.dagbladet.no/nyheter/tvunget-til-a-hvile-i-parkeringshus/73316257\"><figure class=\"sc-1gprk7r-0 eyhIPs\"><picture><img data-defer=\"view\" title=\"Image: Tvunget til å hvile i parkeringshus\" alt=\"Image: Tvunget til å hvile i parkeringshus\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73317382&amp;panox=0&amp;panoy=10.714285714286&amp;panow=100&amp;panoh=50.714285714286&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=407\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 YuxpH title dynamic-sizing\">Tvunget til å hvile</span><span class=\"sc-226e87-0 bSTtWv title dynamic-sizing\">i parkeringshus</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard10\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard10&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Datteren kom aldri hjem lillejulaften\" href=\"https://www.dagbladet.no/tema/datteren-kom-aldri-hjem-lille-julaften/73152770\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Datteren kom aldri hjem lillejulaften\" alt=\"Image: Datteren kom aldri hjem lillejulaften\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73215691&amp;panoy=9.0225563909774&amp;panow=100&amp;panoh=53.383458646617&amp;panox=0&amp;heighty=0&amp;heightx=15.350877192982&amp;heightw=39.473684210526&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 ciDiKz title dynamic-sizing\">Datteren kom aldri</span><span class=\"sc-226e87-0 BsdKn title dynamic-sizing\">hjem lillejulaften</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=\"TV 2-profilen føder på TV \" href=\"https://www.dagbladet.no/video/tv-2-profilen-foder-pa-tv-/0kFrYFwS\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: TV 2-profilen føder på TV \" alt=\"Image: TV 2-profilen føder på TV \" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/0kFrYFwS-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 dYVUKX title dynamic-sizing\">TV 2-profilen</span><span class=\"sc-226e87-0 hwvloE title dynamic-sizing\">føder på TV </span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Det kan ikke tolereres\" href=\"https://www.dagbladet.no/video/-det-kan-ikke-tolereres/uBmuCmjC\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: - Det kan ikke tolereres\" alt=\"Image: - Det kan ikke tolereres\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/uBmuCmjC-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 wFIQJ title dynamic-sizing\">- Det kan</span><span class=\"sc-226e87-0 dYVUKX title dynamic-sizing\">ikke tolereres</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=\"Orgasmetype: - Kan jeg velge?\" href=\"https://www.dagbladet.no/tema/orgasme-type--kan-jeg-velge/73180205\"><figure class=\"sc-1gprk7r-0 kcBjlq\"><picture><img data-defer=\"view\" title=\"Image: Orgasmetype: - Kan jeg velge?\" alt=\"Image: Orgasmetype: - Kan jeg velge?\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73180405&amp;panoy=40.70351758794&amp;panox=0&amp;panow=70.37037037037&amp;panoh=35.678391959799&amp;heighty=37.463976945245&amp;heightw=17.341040462428&amp;heighth=42.363112391931&amp;heightx=22.543352601156&amp;width=320&amp;height=195\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 YuxpH title dynamic-sizing\">Orgasmetype:</span><span class=\"sc-226e87-0 fLRKWS title dynamic-sizing\">- Kan jeg velge?</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle8&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard11&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Demens-frykt? Ta dette arvegrepet\" href=\"https://www.dagbladet.no/tema/demens-frykt-ta-dette-arvegrepet/73180036\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Demens-frykt? Ta dette arvegrepet\" alt=\"Image: Demens-frykt? Ta dette arvegrepet\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=71859175&amp;panoy=32.608695652174&amp;panow=100&amp;panoh=52.173913043478&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=12.444444444444&amp;heightw=40&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 cEKzMg title dynamic-sizing\">Demens-frykt? Ta</span><span class=\"sc-226e87-0 BsdKn title dynamic-sizing\">dette arvegrepet</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=\"Bibel stoppet i tollen\" href=\"https://www.dagbladet.no/video/bibel-stoppet-i-tollen/pUP10DXp\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Bibel stoppet i tollen\" alt=\"Image: Bibel stoppet i tollen\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/pUP10DXp-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 gyclYO title dynamic-sizing\">Bibel stoppet</span><span class=\"sc-226e87-0 eaOcSY title dynamic-sizing\">i tollen</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Skaper rykteflom\" href=\"https://www.dagbladet.no/video/skaper-rykteflom/7HFsZap6\"><figure class=\"sc-1gprk7r-0 dauBDf\"><picture><img data-defer=\"view\" title=\"Image: Skaper rykteflom\" alt=\"Image: Skaper rykteflom\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/7HFsZap6-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 eDBixd title dynamic-sizing\">Skaper rykteflom</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=\"Ufør? - Unngå disse fellene\" href=\"https://www.dagbladet.no/tema/uforefellene-som-gir-pensjonssjokk/73184052\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Ufør? - Unngå disse fellene\" alt=\"Image: Ufør? - Unngå disse fellene\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73184060&amp;panox=0&amp;panow=100&amp;panoh=52.173913043478&amp;panoy=15.942028985507&amp;heightw=40.178571428571&amp;heighth=100&amp;heightx=27.678571428571&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 YuxpH title dynamic-sizing\">Ufør? - Unngå</span><span class=\"sc-226e87-0 gtTUxB title dynamic-sizing\">disse fellene</span></h3></header></a></article><div class=\"adunit-wrapper columns small-4 medium-4 large-4 \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;medium-rectangle9&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Sykeste jeg har sett\" href=\"https://www.dagbladet.no/video/-sykeste-jeg-har-sett/MUuKSzC7\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: - Sykeste jeg har sett\" alt=\"Image: - Sykeste jeg har sett\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/MUuKSzC7-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 kPzQUo title dynamic-sizing\">- Sykeste</span><span class=\"sc-226e87-0 kVyWiO title dynamic-sizing\">jeg har sett</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=\"Glemmer du ord? Hjerneforskerens triks\" href=\"https://www.dagbladet.no/tema/glemmer-du-ord-hjerneforskerens-triks/73122582\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Glemmer du ord? Hjerneforskerens triks\" alt=\"Image: Glemmer du ord? Hjerneforskerens triks\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73144298&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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 eDBixd title dynamic-sizing\">Glemmer du ord?</span><span class=\"sc-226e87-0 hoKTVY title dynamic-sizing\">Hjerneforskerens triks</span></h3></header></a></article></div></div><div class=\"adunit-wrapper columns small-8 medium-8 large-8 \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: { &quot;pos&quot;:&quot;netboard12&quot;, &quot;platform&quot;: &quot;wolverine&quot; } }\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Reagerer på skrekkbilder: - Skummelt\" href=\"https://www.dagbladet.no/video/reagerer-pa-skrekkbilder-skummelt/EPf0xQw5\"><figure class=\"sc-1gprk7r-0 fptXsJ\"><picture><img data-defer=\"view\" title=\"Image: Reagerer på skrekkbilder: - Skummelt\" alt=\"Image: Reagerer på skrekkbilder: - Skummelt\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/EPf0xQw5-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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 hwvloE title dynamic-sizing\">Reagerer på</span><span class=\"sc-226e87-0 gyclYO title dynamic-sizing\">skrekkbilder:</span><span class=\"sc-226e87-0 eUDXpR title dynamic-sizing\">- Skummelt</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=\"Vendepunktet på Pushwagners dødsleie\" href=\"https://www.dagbladet.no/magasinet/datterens-vendepunkt-pa-pushwagners-dodsleie/73155610\"><figure class=\"sc-1gprk7r-0 gSiDQc\"><picture><img data-defer=\"view\" title=\"Image: Vendepunktet på Pushwagners dødsleie\" alt=\"Image: Vendepunktet på Pushwagners dødsleie\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73155639&amp;panow=100&amp;panoh=19.241192411924&amp;panoy=26.016260162602&amp;panox=0&amp;heighty=8.75&amp;heightx=0&amp;heightw=100&amp;heighth=91.25&amp;width=320&amp;height=257\" 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></figure><header><h3 class=\"xavier-headline headline\"><span class=\"sc-226e87-0 fSbsaS title dynamic-sizing\">Vendepunktet på</span><span class=\"sc-226e87-0 hoKTVY title dynamic-sizing\">Pushwagners dødsleie</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>"]
Last ned appen vår
Vi bryr oss om ditt personvern
dagbladet er en del av Aller Media, som er ansvarlig for dine data. Vi bruker dataene til å forbedre og tilpasse tjenestene, tilbudene og annonsene våre.