
-
Reuters: Første reddet ut av tunnel
-
Bærum Høyre: Gir seg som leder
-
Utsetter konklusjonen i habilitetssaken, melder NRK
-
Skuddveksling mellom israelske soldater og Hamas-krigere nord i Gaza, melder Times of Israel
-
Dømt til åtte års forvaring for voldtekt av jente under 14 år
-
Porsgrunn-drapet: Spesialenheten orientert
-
Helsingin Sanomat: Stenger hele grensa mot Russland
-
Bjørnar Moxnes' sykmelding forlenges til 9. januar
-
TV 2: Spesialenehten iverksetter etterforskning mot Øst politidistrikt
-
TV 2: Ny person pågrepet etter påkjørsel i Oslo


Ett tastetrykk:Spar 51 000 i skatt
Slangen kveles- så skjer dette
Annonsørinnhold


Hun vant 4,5millioner!
i samarbeid med Norsk
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:
AKKURAT NÅ:
INDIA:

Reuters: Første reddet ut av tunnel

Bekrefter: - Kona forgiftet
["<style>.ejnyBo.ejnyBo.ejnyBo.ejnyBo{height:0;padding-bottom:51.25%;}/*!sc*/ .fnQDHb.fnQDHb.fnQDHb.fnQDHb{height:0;padding-bottom:49.89%;}/*!sc*/ .gUxcCu.gUxcCu.gUxcCu.gUxcCu{height:0;padding-bottom:80.41%;}/*!sc*/ .fNxeHz.fNxeHz.fNxeHz.fNxeHz{height:0;padding-bottom:89.27%;}/*!sc*/ .fjJyvE.fjJyvE.fjJyvE.fjJyvE{height:0;padding-bottom:50%;}/*!sc*/ .iEicaO.iEicaO.iEicaO.iEicaO{height:0;padding-bottom:53.43%;}/*!sc*/ .kviAry.kviAry.kviAry.kviAry{height:0;padding-bottom:49.91%;}/*!sc*/ .bLPPUH.bLPPUH.bLPPUH.bLPPUH{height:0;padding-bottom:93.28%;}/*!sc*/ .jDKzJI.jDKzJI.jDKzJI.jDKzJI{height:0;padding-bottom:74.37%;}/*!sc*/ .dWxVrg.dWxVrg.dWxVrg.dWxVrg{height:0;padding-bottom:60.41%;}/*!sc*/ .kfhQca.kfhQca.kfhQca.kfhQca{height:0;padding-bottom:67.66%;}/*!sc*/ .hSPccD.hSPccD.hSPccD.hSPccD{height:0;padding-bottom:64.68%;}/*!sc*/ .cqiEQN.cqiEQN.cqiEQN.cqiEQN{height:0;padding-bottom:81.87%;}/*!sc*/ .hyTKLM.hyTKLM.hyTKLM.hyTKLM{height:0;padding-bottom:79.58%;}/*!sc*/ .pRYLl.pRYLl.pRYLl.pRYLl{height:0;padding-bottom:51.75%;}/*!sc*/ .iNTUgw.iNTUgw.iNTUgw.iNTUgw{height:0;padding-bottom:74.62%;}/*!sc*/ .evkaIe.evkaIe.evkaIe.evkaIe{height:0;padding-bottom:70.64%;}/*!sc*/ .cKfKSI.cKfKSI.cKfKSI.cKfKSI{height:0;padding-bottom:108.75%;}/*!sc*/ .jyNJnO.jyNJnO.jyNJnO.jyNJnO{height:0;padding-bottom:100.62%;}/*!sc*/ .bpzRVX.bpzRVX.bpzRVX.bpzRVX{height:0;padding-bottom:80.84%;}/*!sc*/ .qUoPe.qUoPe.qUoPe.qUoPe{height:0;padding-bottom:105.72%;}/*!sc*/ .bbUhCo.bbUhCo.bbUhCo.bbUhCo{height:0;padding-bottom:71.54%;}/*!sc*/ .kaatHb.kaatHb.kaatHb.kaatHb{height:0;padding-bottom:95.77%;}/*!sc*/ .gmpxUf.gmpxUf.gmpxUf.gmpxUf{height:0;padding-bottom:55.62%;}/*!sc*/ .dXDHws.dXDHws.dXDHws.dXDHws{height:0;padding-bottom:101.03%;}/*!sc*/ .cgnnAR.cgnnAR.cgnnAR.cgnnAR{height:0;padding-bottom:66.39%;}/*!sc*/ .dRaWNy.dRaWNy.dRaWNy.dRaWNy{height:0;padding-bottom:75.87%;}/*!sc*/ .lcWYHB.lcWYHB.lcWYHB.lcWYHB{height:0;padding-bottom:63.12%;}/*!sc*/ .jBzAwk.jBzAwk.jBzAwk.jBzAwk{height:0;padding-bottom:56.08%;}/*!sc*/ .kbNwpF.kbNwpF.kbNwpF.kbNwpF{height:0;padding-bottom:70.14%;}/*!sc*/ .hTZISu.hTZISu.hTZISu.hTZISu{height:0;padding-bottom:63.91%;}/*!sc*/ .fnBKjt.fnBKjt.fnBKjt.fnBKjt{height:0;padding-bottom:76.87%;}/*!sc*/ .hGMNlK.hGMNlK.hGMNlK.hGMNlK{height:0;padding-bottom:89.8%;}/*!sc*/ .gMRBUJ.gMRBUJ.gMRBUJ.gMRBUJ{height:0;padding-bottom:59.79%;}/*!sc*/ .hGQBlC.hGQBlC.hGQBlC.hGQBlC{height:0;padding-bottom:57.21%;}/*!sc*/ .kAAGbU.kAAGbU.kAAGbU.kAAGbU{height:0;padding-bottom:57.18%;}/*!sc*/ .gtMzqw.gtMzqw.gtMzqw.gtMzqw{height:0;padding-bottom:109.7%;}/*!sc*/ .hWqjha.hWqjha.hWqjha.hWqjha{height:0;padding-bottom:77.5%;}/*!sc*/ .gzqAYE.gzqAYE.gzqAYE.gzqAYE{height:0;padding-bottom:66.87%;}/*!sc*/ .eAYXY.eAYXY.eAYXY.eAYXY{height:0;padding-bottom:58.75%;}/*!sc*/ data-styled.g308[id=\"x__sc-1an7vu1-0\"]{content:\"ejnyBo,fnQDHb,gUxcCu,fNxeHz,fjJyvE,iEicaO,kviAry,bLPPUH,jDKzJI,dWxVrg,kfhQca,hSPccD,cqiEQN,hyTKLM,pRYLl,iNTUgw,evkaIe,cKfKSI,jyNJnO,bpzRVX,qUoPe,bbUhCo,kaatHb,gmpxUf,dXDHws,cgnnAR,dRaWNy,lcWYHB,jBzAwk,kbNwpF,hTZISu,fnBKjt,hGMNlK,gMRBUJ,hGQBlC,kAAGbU,gtMzqw,hWqjha,gzqAYE,eAYXY,\"}/*!sc*/ .beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:1.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.beDNpZ.beDNpZ.beDNpZ.beDNpZ{font-size:0.6em!important;}}/*!sc*/ .bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:3.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.bwGQrt.bwGQrt.bwGQrt.bwGQrt{font-size:1.1em!important;}}/*!sc*/ .cFtCN.cFtCN.cFtCN.cFtCN{font-size:2.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.cFtCN.cFtCN.cFtCN.cFtCN{font-size:0.7em!important;}}/*!sc*/ .gPIxea.gPIxea.gPIxea.gPIxea{font-size:3.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gPIxea.gPIxea.gPIxea.gPIxea{font-size:1.1em!important;}}/*!sc*/ .ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ftetSQ.ftetSQ.ftetSQ.ftetSQ{font-size:1.7em!important;}}/*!sc*/ .egjpuh.egjpuh.egjpuh.egjpuh{font-size:8.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.egjpuh.egjpuh.egjpuh.egjpuh{font-size:2.9em!important;}}/*!sc*/ .bWSnVS.bWSnVS.bWSnVS.bWSnVS{font-size:3.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.bWSnVS.bWSnVS.bWSnVS.bWSnVS{font-size:1.3em!important;}}/*!sc*/ .dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.dyaAfc.dyaAfc.dyaAfc.dyaAfc{font-size:1.2em!important;}}/*!sc*/ .bxkUEU.bxkUEU.bxkUEU.bxkUEU{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.bxkUEU.bxkUEU.bxkUEU.bxkUEU{font-size:2.5em!important;}}/*!sc*/ .ewQOt.ewQOt.ewQOt.ewQOt{font-size:7.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ewQOt.ewQOt.ewQOt.ewQOt{font-size:3em!important;}}/*!sc*/ .jfvMWJ.jfvMWJ.jfvMWJ.jfvMWJ{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfvMWJ.jfvMWJ.jfvMWJ.jfvMWJ{font-size:0.9em!important;}}/*!sc*/ .iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:2.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.iFlEmK.iFlEmK.iFlEmK.iFlEmK{font-size:1em!important;}}/*!sc*/ .dqFtBy.dqFtBy.dqFtBy.dqFtBy{font-size:11em!important;}/*!sc*/ @media only screen and (max-width:640px){.dqFtBy.dqFtBy.dqFtBy.dqFtBy{font-size:3.9em!important;}}/*!sc*/ .fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:7.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.fZJFvq.fZJFvq.fZJFvq.fZJFvq{font-size:2.8em!important;}}/*!sc*/ .hQxAYP.hQxAYP.hQxAYP.hQxAYP{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.hQxAYP.hQxAYP.hQxAYP.hQxAYP{font-size:2em!important;}}/*!sc*/ .bvsVFh.bvsVFh.bvsVFh.bvsVFh{font-size:7.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.bvsVFh.bvsVFh.bvsVFh.bvsVFh{font-size:2.5em!important;}}/*!sc*/ .kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:8.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kUqUJf.kUqUJf.kUqUJf.kUqUJf{font-size:2.9em!important;}}/*!sc*/ .HdCIH.HdCIH.HdCIH.HdCIH{font-size:11.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.HdCIH.HdCIH.HdCIH.HdCIH{font-size:4em!important;}}/*!sc*/ .kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:6.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.kyzRFP.kyzRFP.kyzRFP.kyzRFP{font-size:2.2em!important;}}/*!sc*/ .epoJzD.epoJzD.epoJzD.epoJzD{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.epoJzD.epoJzD.epoJzD.epoJzD{font-size:1.1em!important;}}/*!sc*/ .fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fIeyCx.fIeyCx.fIeyCx.fIeyCx{font-size:1.2em!important;}}/*!sc*/ .iYgBvA.iYgBvA.iYgBvA.iYgBvA{font-size:2.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.iYgBvA.iYgBvA.iYgBvA.iYgBvA{font-size:0.8em!important;}}/*!sc*/ .iEukpb.iEukpb.iEukpb.iEukpb{font-size:8.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.iEukpb.iEukpb.iEukpb.iEukpb{font-size:3.1em!important;}}/*!sc*/ .iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iXjdLY.iXjdLY.iXjdLY.iXjdLY{font-size:1.6em!important;}}/*!sc*/ .cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.cnjOqe.cnjOqe.cnjOqe.cnjOqe{font-size:1.7em!important;}}/*!sc*/ .gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.gWsWwS.gWsWwS.gWsWwS.gWsWwS{font-size:1.8em!important;}}/*!sc*/ .dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dBWQRi.dBWQRi.dBWQRi.dBWQRi{font-size:1.6em!important;}}/*!sc*/ .kukeCs.kukeCs.kukeCs.kukeCs{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.kukeCs.kukeCs.kukeCs.kukeCs{font-size:2.2em!important;}}/*!sc*/ .bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:4.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bcCfuJ.bcCfuJ.bcCfuJ.bcCfuJ{font-size:1.4em!important;}}/*!sc*/ .bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.bkgkdp.bkgkdp.bkgkdp.bkgkdp{font-size:1.6em!important;}}/*!sc*/ .tqGkg.tqGkg.tqGkg.tqGkg{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.tqGkg.tqGkg.tqGkg.tqGkg{font-size:1.9em!important;}}/*!sc*/ .dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dWzMnA.dWzMnA.dWzMnA.dWzMnA{font-size:2em!important;}}/*!sc*/ .ddbCJZ.ddbCJZ.ddbCJZ.ddbCJZ{font-size:5.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ddbCJZ.ddbCJZ.ddbCJZ.ddbCJZ{font-size:2.1em!important;}}/*!sc*/ .gVRWAB.gVRWAB.gVRWAB.gVRWAB{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gVRWAB.gVRWAB.gVRWAB.gVRWAB{font-size:1.5em!important;}}/*!sc*/ .inksEV.inksEV.inksEV.inksEV{font-size:3.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.inksEV.inksEV.inksEV.inksEV{font-size:1.3em!important;}}/*!sc*/ .bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.bxtuZJ.bxtuZJ.bxtuZJ.bxtuZJ{font-size:2em!important;}}/*!sc*/ .cKlSIC.cKlSIC.cKlSIC.cKlSIC{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cKlSIC.cKlSIC.cKlSIC.cKlSIC{font-size:1.3em!important;}}/*!sc*/ .dbonoY.dbonoY.dbonoY.dbonoY{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.dbonoY.dbonoY.dbonoY.dbonoY{font-size:2em!important;}}/*!sc*/ .jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:5.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.jJrnNf.jJrnNf.jJrnNf.jJrnNf{font-size:2.1em!important;}}/*!sc*/ .gALHSm.gALHSm.gALHSm.gALHSm{font-size:5.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.gALHSm.gALHSm.gALHSm.gALHSm{font-size:1.9em!important;}}/*!sc*/ .bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.bNRoJL.bNRoJL.bNRoJL.bNRoJL{font-size:1.5em!important;}}/*!sc*/ .iliEgZ.iliEgZ.iliEgZ.iliEgZ{font-size:9.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.iliEgZ.iliEgZ.iliEgZ.iliEgZ{font-size:3.4em!important;}}/*!sc*/ .bpsQVB.bpsQVB.bpsQVB.bpsQVB{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.bpsQVB.bpsQVB.bpsQVB.bpsQVB{font-size:2.1em!important;}}/*!sc*/ .fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.fNDhDy.fNDhDy.fNDhDy.fNDhDy{font-size:0.9em!important;}}/*!sc*/ .frzFun.frzFun.frzFun.frzFun{font-size:2.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.frzFun.frzFun.frzFun.frzFun{font-size:0.9em!important;}}/*!sc*/ .dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfgvpn.dfgvpn.dfgvpn.dfgvpn{font-size:1.9em!important;}}/*!sc*/ .iNHyie.iNHyie.iNHyie.iNHyie{font-size:2.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.iNHyie.iNHyie.iNHyie.iNHyie{font-size:0.7em!important;}}/*!sc*/ .dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:1.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.dDKeDQ.dDKeDQ.dDKeDQ.dDKeDQ{font-size:0.6em!important;}}/*!sc*/ .cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:2.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cyVXzf.cyVXzf.cyVXzf.cyVXzf{font-size:0.8em!important;}}/*!sc*/ .inhdgd.inhdgd.inhdgd.inhdgd{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.inhdgd.inhdgd.inhdgd.inhdgd{font-size:1.9em!important;}}/*!sc*/ .epYOIN.epYOIN.epYOIN.epYOIN{font-size:6.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.epYOIN.epYOIN.epYOIN.epYOIN{font-size:2.3em!important;}}/*!sc*/ .criDNb.criDNb.criDNb.criDNb{font-size:5.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.criDNb.criDNb.criDNb.criDNb{font-size:2em!important;}}/*!sc*/ .emaxbb.emaxbb.emaxbb.emaxbb{font-size:4.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.emaxbb.emaxbb.emaxbb.emaxbb{font-size:1.7em!important;}}/*!sc*/ .gjEbOi.gjEbOi.gjEbOi.gjEbOi{font-size:13.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.gjEbOi.gjEbOi.gjEbOi.gjEbOi{font-size:4.9em!important;}}/*!sc*/ .hXgjw.hXgjw.hXgjw.hXgjw{font-size:9.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.hXgjw.hXgjw.hXgjw.hXgjw{font-size:3.3em!important;}}/*!sc*/ .jPnLUB.jPnLUB.jPnLUB.jPnLUB{font-size:6.4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jPnLUB.jPnLUB.jPnLUB.jPnLUB{font-size:2.3em!important;}}/*!sc*/ .eCHIew.eCHIew.eCHIew.eCHIew{font-size:9.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.eCHIew.eCHIew.eCHIew.eCHIew{font-size:3.5em!important;}}/*!sc*/ .ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ggbHpa.ggbHpa.ggbHpa.ggbHpa{font-size:2.8em!important;}}/*!sc*/ .hrVcDN.hrVcDN.hrVcDN.hrVcDN{font-size:4.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.hrVcDN.hrVcDN.hrVcDN.hrVcDN{font-size:1.7em!important;}}/*!sc*/ .jdcGMN.jdcGMN.jdcGMN.jdcGMN{font-size:4em!important;}/*!sc*/ @media only screen and (max-width:640px){.jdcGMN.jdcGMN.jdcGMN.jdcGMN{font-size:1.4em!important;}}/*!sc*/ .kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:3.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.kMqJSM.kMqJSM.kMqJSM.kMqJSM{font-size:1.3em!important;}}/*!sc*/ .dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:6.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.dQSCBR.dQSCBR.dQSCBR.dQSCBR{font-size:2.4em!important;}}/*!sc*/ .erpCho.erpCho.erpCho.erpCho{font-size:2.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.erpCho.erpCho.erpCho.erpCho{font-size:1em!important;}}/*!sc*/ .iITVJY.iITVJY.iITVJY.iITVJY{font-size:3.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iITVJY.iITVJY.iITVJY.iITVJY{font-size:1em!important;}}/*!sc*/ .kNhGgX.kNhGgX.kNhGgX.kNhGgX{font-size:3.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.kNhGgX.kNhGgX.kNhGgX.kNhGgX{font-size:1.3em!important;}}/*!sc*/ .hIOHzH.hIOHzH.hIOHzH.hIOHzH{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.hIOHzH.hIOHzH.hIOHzH.hIOHzH{font-size:2.3em!important;}}/*!sc*/ .eQoVaS.eQoVaS.eQoVaS.eQoVaS{font-size:5.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.eQoVaS.eQoVaS.eQoVaS.eQoVaS{font-size:2em!important;}}/*!sc*/ .Uccen.Uccen.Uccen.Uccen{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.Uccen.Uccen.Uccen.Uccen{font-size:1.7em!important;}}/*!sc*/ .jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jGSTdz.jGSTdz.jGSTdz.jGSTdz{font-size:1.6em!important;}}/*!sc*/ .jiGVVj.jiGVVj.jiGVVj.jiGVVj{font-size:3.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.jiGVVj.jiGVVj.jiGVVj.jiGVVj{font-size:1.2em!important;}}/*!sc*/ .SXEmE.SXEmE.SXEmE.SXEmE{font-size:5.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.SXEmE.SXEmE.SXEmE.SXEmE{font-size:2.1em!important;}}/*!sc*/ .hsPeia.hsPeia.hsPeia.hsPeia{font-size:4.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.hsPeia.hsPeia.hsPeia.hsPeia{font-size:1.4em!important;}}/*!sc*/ .jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:6.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.jfcAvK.jfcAvK.jfcAvK.jfcAvK{font-size:2.4em!important;}}/*!sc*/ .jdgMzU.jdgMzU.jdgMzU.jdgMzU{font-size:3em!important;}/*!sc*/ @media only screen and (max-width:640px){.jdgMzU.jdgMzU.jdgMzU.jdgMzU{font-size:1em!important;}}/*!sc*/ .hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:5em!important;}/*!sc*/ @media only screen and (max-width:640px){.hPDIHE.hPDIHE.hPDIHE.hPDIHE{font-size:1.8em!important;}}/*!sc*/ .hpQSgl.hpQSgl.hpQSgl.hpQSgl{font-size:1.7em!important;}/*!sc*/ @media only screen and (max-width:640px){.hpQSgl.hpQSgl.hpQSgl.hpQSgl{font-size:0.5em!important;}}/*!sc*/ .kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:2em!important;}/*!sc*/ @media only screen and (max-width:640px){.kwLuaB.kwLuaB.kwLuaB.kwLuaB{font-size:0.7em!important;}}/*!sc*/ .kmfDed.kmfDed.kmfDed.kmfDed{font-size:8.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.kmfDed.kmfDed.kmfDed.kmfDed{font-size:3.1em!important;}}/*!sc*/ .jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.jtCXvA.jtCXvA.jtCXvA.jtCXvA{font-size:1.8em!important;}}/*!sc*/ .cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:7em!important;}/*!sc*/ @media only screen and (max-width:640px){.cUXKOF.cUXKOF.cUXKOF.cUXKOF{font-size:2.4em!important;}}/*!sc*/ .jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.jEhvtw.jEhvtw.jEhvtw.jEhvtw{font-size:1.1em!important;}}/*!sc*/ .gApunH.gApunH.gApunH.gApunH{font-size:4.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.gApunH.gApunH.gApunH.gApunH{font-size:1.8em!important;}}/*!sc*/ .cGLrSG.cGLrSG.cGLrSG.cGLrSG{font-size:4.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.cGLrSG.cGLrSG.cGLrSG.cGLrSG{font-size:1.6em!important;}}/*!sc*/ .gRLJwN.gRLJwN.gRLJwN.gRLJwN{font-size:5.3em!important;}/*!sc*/ @media only screen and (max-width:640px){.gRLJwN.gRLJwN.gRLJwN.gRLJwN{font-size:1.8em!important;}}/*!sc*/ .bWzzkU.bWzzkU.bWzzkU.bWzzkU{font-size:7.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.bWzzkU.bWzzkU.bWzzkU.bWzzkU{font-size:2.6em!important;}}/*!sc*/ .dfserP.dfserP.dfserP.dfserP{font-size:3.1em!important;}/*!sc*/ @media only screen and (max-width:640px){.dfserP.dfserP.dfserP.dfserP{font-size:1em!important;}}/*!sc*/ .kVJNPR.kVJNPR.kVJNPR.kVJNPR{font-size:2.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.kVJNPR.kVJNPR.kVJNPR.kVJNPR{font-size:0.8em!important;}}/*!sc*/ .cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:4.5em!important;}/*!sc*/ @media only screen and (max-width:640px){.cJcNIn.cJcNIn.cJcNIn.cJcNIn{font-size:1.5em!important;}}/*!sc*/ .beQydf.beQydf.beQydf.beQydf{font-size:5.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.beQydf.beQydf.beQydf.beQydf{font-size:1.7em!important;}}/*!sc*/ .ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:6.9em!important;}/*!sc*/ @media only screen and (max-width:640px){.ldTjgH.ldTjgH.ldTjgH.ldTjgH{font-size:2.4em!important;}}/*!sc*/ .iAWFly.iAWFly.iAWFly.iAWFly{font-size:6.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iAWFly.iAWFly.iAWFly.iAWFly{font-size:2.2em!important;}}/*!sc*/ .ijicdz.ijicdz.ijicdz.ijicdz{font-size:2.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.ijicdz.ijicdz.ijicdz.ijicdz{font-size:1em!important;}}/*!sc*/ .iWZcdV.iWZcdV.iWZcdV.iWZcdV{font-size:9.2em!important;}/*!sc*/ @media only screen and (max-width:640px){.iWZcdV.iWZcdV.iWZcdV.iWZcdV{font-size:3.3em!important;}}/*!sc*/ .inoUtg.inoUtg.inoUtg.inoUtg{font-size:8.8em!important;}/*!sc*/ @media only screen and (max-width:640px){.inoUtg.inoUtg.inoUtg.inoUtg{font-size:3.1em!important;}}/*!sc*/ .iyrywY.iyrywY.iyrywY.iyrywY{font-size:5.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.iyrywY.iyrywY.iyrywY.iyrywY{font-size:1.8em!important;}}/*!sc*/ .jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:1.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.jRIgeY.jRIgeY.jRIgeY.jRIgeY{font-size:0.5em!important;}}/*!sc*/ .fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:4.6em!important;}/*!sc*/ @media only screen and (max-width:640px){.fTAjeM.fTAjeM.fTAjeM.fTAjeM{font-size:1.5em!important;}}/*!sc*/ data-styled.g309[id=\"x__pt8tzk-0\"]{content:\"beDNpZ,bwGQrt,cFtCN,gPIxea,ftetSQ,egjpuh,bWSnVS,dyaAfc,bxkUEU,ewQOt,jfvMWJ,iFlEmK,dqFtBy,fZJFvq,hQxAYP,bvsVFh,kUqUJf,HdCIH,kyzRFP,epoJzD,fIeyCx,iYgBvA,iEukpb,iXjdLY,cnjOqe,gWsWwS,dBWQRi,kukeCs,bcCfuJ,bkgkdp,tqGkg,dWzMnA,ddbCJZ,gVRWAB,inksEV,bxtuZJ,cKlSIC,dbonoY,jJrnNf,gALHSm,bNRoJL,iliEgZ,bpsQVB,fNDhDy,frzFun,dfgvpn,iNHyie,dDKeDQ,cyVXzf,inhdgd,epYOIN,criDNb,emaxbb,gjEbOi,hXgjw,jPnLUB,eCHIew,ggbHpa,hrVcDN,jdcGMN,kMqJSM,dQSCBR,erpCho,iITVJY,kNhGgX,hIOHzH,eQoVaS,Uccen,jGSTdz,jiGVVj,SXEmE,hsPeia,jfcAvK,jdgMzU,hPDIHE,hpQSgl,kwLuaB,kmfDed,jtCXvA,cUXKOF,jEhvtw,gApunH,cGLrSG,gRLJwN,bWzzkU,dfserP,kVJNPR,cJcNIn,beQydf,ldTjgH,iAWFly,ijicdz,iWZcdV,inoUtg,iyrywY,jRIgeY,fTAjeM,\"}/*!sc*/ </style><div class=\"row xrow flex-initial\"><div id=\"apos-netboard3\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard3\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Fanges i skyttergraven: - Enorme tap\" href=\"https://www.dagbladet.no/video/fanges-i-skyttergraven-enorme-tap/1E3hsDgi\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Fanges i skyttergraven: - Enorme tap\" alt=\"Image: Fanges i skyttergraven: - Enorme tap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/1E3hsDgi-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=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Fanges i skyttergraven:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">- Enorme tap</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=\"Nye pensjonsregler: Disse får mer\" href=\"https://www.dagbladet.no/tema/ufor-dette-betyr-nye-pensjonsregler/80494109\"><figure class=\"x__sc-1an7vu1-0 ejnyBo\"><picture><img data-defer=\"view\" title=\"Image: Nye pensjonsregler: Disse får mer\" alt=\"Image: Nye pensjonsregler: Disse får mer\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80496131&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=164\" 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=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Nye pensjonsregler:</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Disse får mer</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avhørt: - Mye mer å si\" href=\"https://www.dagbladet.no/sport/avhort-mye-mer-a-si/80587779\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Avhørt: - Mye mer å si\" alt=\"Image: Avhørt: - Mye mer å si\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80588292&amp;panoh=50.91926618705&amp;panoy=34.532374100719&amp;panox=0&amp;panow=99.893674641148&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">Avhørt: - Mye</span><span class=\"x__pt8tzk-0 egjpuh title dynamic-sizing\">mer å si</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ber Brenna svare\" href=\"https://www.dagbladet.no/nyheter/ber-brenna-svare/80588477\"><figure class=\"x__sc-1an7vu1-0 gUxcCu\"><picture><img data-defer=\"view\" title=\"Image: Ber Brenna svare\" alt=\"Image: Ber Brenna svare\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80588487&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=485&amp;height=390\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">Ber Brenna svare</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Tror ikke på ham\" href=\"https://www.dagbladet.no/nyheter/tror-ikke-pa-ham/80583469\"><figure class=\"x__sc-1an7vu1-0 fNxeHz\"><picture><img data-defer=\"view\" title=\"Image: - Tror ikke på ham\" alt=\"Image: - Tror ikke på ham\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80583538&amp;panox=16&amp;panoy=19.760479041916&amp;panow=84&amp;panoh=42.51497005988&amp;heighty=6.0773480662983&amp;heightx=51.470588235294&amp;heightw=33.088235294118&amp;heighth=81.21546961326&amp;width=485&amp;height=433\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">- Tror ikke på ham</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Rystende samtale\" href=\"https://www.dagbladet.no/sport/rystende-samtale/80585802\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Rystende samtale\" alt=\"Image: Rystende samtale\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80585845&amp;panox=0.86580086580087&amp;panow=91.341991341991&amp;panoh=26.373626373626&amp;panoy=26.007326007326&amp;heightw=43.90243902439&amp;heighth=60.493827160494&amp;heighty=8.2304526748971&amp;heightx=24.878048780488&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bxkUEU title dynamic-sizing\">Rystende</span><span class=\"x__pt8tzk-0 ewQOt title dynamic-sizing\">samtale</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=\"Små tegn røper psykopat-kone\" href=\"https://www.dagbladet.no/tema/sma-tegn-roper-psykopat-kone-1/80455864\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Små tegn røper psykopat-kone\" alt=\"Image: Små tegn røper psykopat-kone\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80494420&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Små tegn røper</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">psykopat-kone</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=\"Beviser løgnen: - De blir krepsemat\" href=\"https://www.dagbladet.no/video/beviser-lognen-de-blir-krepsemat/bGlrS68M\"><figure class=\"x__sc-1an7vu1-0 iEicaO\"><picture><img data-defer=\"view\" title=\"Image: Beviser løgnen: - De blir krepsemat\" alt=\"Image: Beviser løgnen: - De blir krepsemat\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/bGlrS68M-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=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Beviser løgnen:</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">- De blir krepsemat</span></h3></header></a></article><div id=\"apos-medium-rectangle3\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle3\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle3&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Gir seg som leder\" href=\"https://www.dagbladet.no/nyheter/gir-seg-som-leder/80587580\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Gir seg som leder\" alt=\"Image: Gir seg som leder\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80222691&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=36.529680365297&amp;heightw=40.994420091324&amp;heighth=99.847794520548&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dqFtBy title dynamic-sizing\">Gir seg</span><span class=\"x__pt8tzk-0 fZJFvq title dynamic-sizing\">som leder</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Svarer på ryktene\" href=\"https://www.dagbladet.no/kjendis/svarer-pa-ryktene/80587305\"><figure class=\"x__sc-1an7vu1-0 bLPPUH\"><picture><img data-defer=\"view\" title=\"Image: Svarer på ryktene\" alt=\"Image: Svarer på ryktene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80588006&amp;panow=99.842766981132&amp;panoh=23.903508552632&amp;panoy=24.013157894737&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=402&amp;height=375\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">Svarer på</span><span class=\"x__pt8tzk-0 bvsVFh title dynamic-sizing\">ryktene</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Hull i hjertet\" href=\"https://www.dagbladet.no/kjendis/hull-i-hjertet/80586682\"><figure class=\"x__sc-1an7vu1-0 jDKzJI\"><picture><img data-defer=\"view\" title=\"Image: - Hull i hjertet\" alt=\"Image: - Hull i hjertet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80586691&amp;panoy=5.2478134110787&amp;panox=0&amp;panow=99.842766981132&amp;panoh=21.185616909621&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=402&amp;height=299\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kUqUJf title dynamic-sizing\">- Hull i</span><span class=\"x__pt8tzk-0 egjpuh title dynamic-sizing\">hjertet</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Herjer: - Ustoppelig\" href=\"https://www.dagbladet.no/sport/herjer-ustoppelig/80587004\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Herjer: - Ustoppelig\" alt=\"Image: Herjer: - Ustoppelig\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80587029&amp;panoy=5.3691275167785&amp;panox=0&amp;panow=100&amp;panoh=47.651006711409&amp;heightx=26.923076923077&amp;heightw=43.269230769231&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=\"x__pt8tzk-0 HdCIH title dynamic-sizing\">Herjer:</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">- Ustoppelig</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard4\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard4\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ned i vekt: 25 centimeter smalere!\" href=\"https://www.dagbladet.no/tema/ned-25-kilo-og-25-centimeter-smalere/80550959\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ned i vekt: 25 centimeter smalere!\" alt=\"Image: Ned i vekt: 25 centimeter smalere!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80552092&amp;panoy=9.0909090909091&amp;panox=4.8148148148148&amp;panow=76.748971111111&amp;panoh=70.931537373737&amp;heightw=22.474111335013&amp;heighth=100.15325655172&amp;heighty=0.15325655172413&amp;heightx=32.241813602015&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=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Ned i vekt: 25</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">centimeter smalere!</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=\"Settes ut av intimtatoveringen\" href=\"https://www.dagbladet.no/video/settes-ut-av-intimtatoveringen/zfRrzgIK\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Settes ut av intimtatoveringen\" alt=\"Image: Settes ut av intimtatoveringen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/zfRrzgIK-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=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">Settes ut av</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">intimtatoveringen</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Prisene skyter i været\" href=\"https://www.dagbladet.no/sport/prisene-skyter-i-vaeret/80587927\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Prisene skyter i været\" alt=\"Image: Prisene skyter i været\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=79913964&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=12.142857142857&amp;panox=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iEukpb title dynamic-sizing\">Prisene</span><span class=\"x__pt8tzk-0 ftetSQ title dynamic-sizing\">skyter i været</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Absolutt ikke et PR-stunt\" href=\"https://www.dagbladet.no/kjendis/absolutt-ikke-et-pr-stunt/80584979\"><figure class=\"x__sc-1an7vu1-0 dWxVrg\"><picture><img data-defer=\"view\" title=\"Image: - Absolutt ikke et PR-stunt\" alt=\"Image: - Absolutt ikke et PR-stunt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80584671&amp;panoy=3.2466338129496&amp;panox=0.15948995215311&amp;panow=99.840510047847&amp;panoh=51.558752517986&amp;heighty=1.5659959731544&amp;heightw=40.476190178571&amp;heighth=98.434004026846&amp;heightx=29.464285714286&amp;width=485&amp;height=293\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">- Absolutt ikke</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">et PR-stunt</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=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Norge-melding: - Skremmende\" href=\"https://www.dagbladet.no/sport/norge-melding-skremmende/80584551\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Norge-melding: - Skremmende\" alt=\"Image: Norge-melding: - Skremmende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80584746&amp;panoy=10.63829787234&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panox=0&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=\"x__pt8tzk-0 cnjOqe title dynamic-sizing\">Norge-melding:</span><span class=\"x__pt8tzk-0 gWsWwS title dynamic-sizing\">- Skremmende</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Bruk alltid kondom!\" href=\"https://www.dagbladet.no/kjendis/bruk-alltid-kondom/80544490\"><figure class=\"x__sc-1an7vu1-0 kfhQca\"><picture><img data-defer=\"view\" title=\"Image: - Bruk alltid kondom!\" alt=\"Image: - Bruk alltid kondom!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80201959&amp;panox=0&amp;panow=100&amp;panoh=22.611464968153&amp;panoy=14.012738853503&amp;heighty=0&amp;heightx=22.159090909091&amp;heightw=51.136363636364&amp;heighth=55.263157894737&amp;width=402&amp;height=272\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">- Bruk alltid</span><span class=\"x__pt8tzk-0 kukeCs title dynamic-sizing\">kondom!</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=\"- Alle har vært utro\" href=\"https://www.dagbladet.no/tema/alle-har-vaert-utro/80395204\"><figure class=\"x__sc-1an7vu1-0 hSPccD\"><picture><img data-defer=\"view\" title=\"Image: - Alle har vært utro\" alt=\"Image: - Alle har vært utro\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80402904&amp;panox=0&amp;panoy=23.529411764706&amp;panow=88.961038961039&amp;panoh=45.424836601307&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=207\" 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=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">- Alle har</span><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">vært utro</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tusenvis av nakne mennesker\" href=\"https://www.dagbladet.no/video/tusenvis-av-nakne-mennesker/IyvV4OjF\"><figure class=\"x__sc-1an7vu1-0 cqiEQN\"><picture><img data-defer=\"view\" title=\"Image: Tusenvis av nakne mennesker\" alt=\"Image: Tusenvis av nakne mennesker\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/IyvV4OjF-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=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Tusenvis av</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">nakne mennesker</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=\"Svimlende billig sko\" href=\"https://tinyurl.com/tights-db?allerID=1202511255\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Svimlende billig sko\" alt=\"Image: Svimlende billig sko\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/80545515.jpg?imageId=80545515&amp;x=21.308523&amp;y=28.297872&amp;cropw=58.823529&amp;croph=46.914894&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bcCfuJ title dynamic-sizing\">Svimlende</span><span class=\"x__pt8tzk-0 bkgkdp title dynamic-sizing\">billig sko</span></h3><span hidden=\"\" class=\"announce\">i samarbeid med <span></span></span></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslørt etter maskeglipp på direkten\" href=\"https://www.dagbladet.no/kjendis/avslort-etter-maskeglipp-pa-direkten/80582271\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Avslørt etter maskeglipp på direkten\" alt=\"Image: Avslørt etter maskeglipp på direkten\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80582128&amp;panoy=48.571428571429&amp;panox=0&amp;panow=100&amp;panoh=33.809523809524&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 tqGkg title dynamic-sizing\">Avslørt etter</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">maskeglipp</span><span class=\"x__pt8tzk-0 ddbCJZ title dynamic-sizing\">på direkten</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ut mot FHI-råd: - Skuffende svake\" href=\"https://www.dagbladet.no/nyheter/ut-mot-fhi-rad-skuffende-svake/80569582\"><figure class=\"x__sc-1an7vu1-0 hyTKLM\"><picture><img data-defer=\"view\" title=\"Image: Ut mot FHI-råd: - Skuffende svake\" alt=\"Image: Ut mot FHI-råd: - Skuffende svake\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80571658&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=386\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gVRWAB title dynamic-sizing\">Ut mot FHI-råd:</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">- Skuffende svake</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Drakk for mye vann - døde\" href=\"https://www.dagbladet.no/nyheter/drakk-for-mye-vann-dode/80581293\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Drakk for mye vann - døde\" alt=\"Image: Drakk for mye vann - døde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80581636&amp;panoy=3.8167938931298&amp;panow=99.842766981132&amp;panoh=55.47073740458&amp;panox=0&amp;heighty=4.5&amp;heightx=58.823529411765&amp;heightw=28.379772755418&amp;heighth=74.333333&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">Drakk for mye</span><span class=\"x__pt8tzk-0 bxtuZJ title dynamic-sizing\">vann - døde</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"NRK-refs: - Langt over grensa\" href=\"https://www.dagbladet.no/sport/nrk-refs-langt-over-grensa/80586247\"><figure class=\"x__sc-1an7vu1-0 pRYLl\"><picture><img data-defer=\"view\" title=\"Image: NRK-refs: - Langt over grensa\" alt=\"Image: NRK-refs: - Langt over grensa\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80376780&amp;panoh=50.714285714286&amp;panoy=28.571428571429&amp;panox=0&amp;panow=100&amp;heightx=37.556561085973&amp;heighth=100&amp;heighty=0&amp;heightw=40.723981900452&amp;width=485&amp;height=251\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cKlSIC title dynamic-sizing\">NRK-refs: - Langt</span><span class=\"x__pt8tzk-0 dbonoY title dynamic-sizing\">over grensa</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard5\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard5\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Flykter for livet\" href=\"https://www.dagbladet.no/video/slass-rett-ved-golfhullet-/knib9tsh\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Flykter for livet\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/80582652.jpg?imageId=80582652&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/11/16/a429471e-53ef-489d-9eea-6b9c70d1cd7d/dyr_pa_golfbana_gif_kobra2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/11/16/a429471e-53ef-489d-9eea-6b9c70d1cd7d/dyr_pa_golfbana_gif_kobra2.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jJrnNf title dynamic-sizing\">Flykter</span><span class=\"x__pt8tzk-0 gALHSm title dynamic-sizing\">for livet</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=\"Ørje-drapet: - Har mine teorier\" href=\"https://www.dagbladet.no/tema/orje-drapet-har-mine-teorier/80556550\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Ørje-drapet: - Har mine teorier\" alt=\"Image: Ørje-drapet: - Har mine teorier\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80556973&amp;panox=0.1073536231884&amp;panow=100.10735362319&amp;panoh=30.664725764192&amp;panoy=27.510917030568&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=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Ørje-drapet:</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">- Har mine teorier</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ukrainsk avhopper likvidert\" href=\"https://www.dagbladet.no/nyheter/ukrainsk-avhopper-likvidert/80578118\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Ukrainsk avhopper likvidert\" alt=\"Image: Ukrainsk avhopper likvidert\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80578142&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bNRoJL title dynamic-sizing\">Ukrainsk avhopper</span><span class=\"x__pt8tzk-0 iliEgZ title dynamic-sizing\">likvidert</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Røper ny kjæreste\" href=\"https://www.dagbladet.no/kjendis/roper-ny-kjaereste/80584667\"><figure class=\"x__sc-1an7vu1-0 iNTUgw\"><picture><img data-defer=\"view\" title=\"Image: Røper ny kjæreste\" alt=\"Image: Røper ny kjæreste\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=79863061&amp;panoy=12.244897959184&amp;panox=0&amp;panow=99.842766981132&amp;panoh=49.433106122449&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=300\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 bpsQVB title dynamic-sizing\">Røper ny</span><span class=\"x__pt8tzk-0 kyzRFP title dynamic-sizing\">kjæreste</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Reaksjonene hagler: - Trekk opp buksene\" href=\"https://www.dagbladet.no/nyheter/reaksjonene-hagler-trekk-opp-buksene/80579386\"><figure class=\"x__sc-1an7vu1-0 evkaIe\"><picture><img data-defer=\"view\" title=\"Image: Reaksjonene hagler: - Trekk opp buksene\" alt=\"Image: Reaksjonene hagler: - Trekk opp buksene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80579393&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heighty=19.012344444444&amp;heightw=27.96815576324&amp;heighth=80.987655555556&amp;heightx=31.464174454829&amp;width=402&amp;height=284\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">Reaksjonene hagler:</span><span class=\"x__pt8tzk-0 frzFun title dynamic-sizing\">- Trekk opp buksene</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nekter å svare\" href=\"https://www.dagbladet.no/kjendis/nekter-a-svare/80583618\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Nekter å svare\" alt=\"Image: Nekter å svare\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80582389&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">Nekter å svare</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=\"Sjokkstudie om barn og fedre: Urovekkende\" href=\"https://www.dagbladet.no/tema/sjokkstudie-om-barn-og-fedre-urovekkende/80390590\"><figure class=\"x__sc-1an7vu1-0 cKfKSI\"><picture><img data-defer=\"view\" title=\"Image: Sjokkstudie om barn og fedre: Urovekkende\" alt=\"Image: Sjokkstudie om barn og fedre: Urovekkende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80390821&amp;panoy=35.897435897436&amp;panox=11.158391489362&amp;panow=88.841608510638&amp;panoh=45.370371794872&amp;heightx=35.616438356164&amp;heightw=40.994420091324&amp;heighth=99.847794520548&amp;heighty=0.15220547945205&amp;width=320&amp;height=348\" 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=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Sjokkstudie om barn</span><span class=\"x__pt8tzk-0 dDKeDQ title dynamic-sizing\">og fedre: Urovekkende</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Stjeler millionbil - metoden ryster\" href=\"https://www.dagbladet.no/video/milliontyveriet-sjokkerer/lpLPDMJP\"><figure class=\"x__sc-1an7vu1-0 jyNJnO moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Stjeler millionbil - metoden ryster\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/80578478.jpg?imageId=80578478&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=322\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/11/24/287b2ffe-a17c-4b54-972b-51d6894afb36/gifrolls_-_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/11/24/287b2ffe-a17c-4b54-972b-51d6894afb36/gifrolls_-_1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Stjeler millionbil</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">- metoden ryster</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=\"Elleville priser!\" href=\"https://tinyurl.com/sommersalg-db1?allerID=1202311255\"><div class=\"content-marketing-ribbon\"><h3>Annonsørinnhold</h3><img data-src=\"https://www.dagbladet.no/files/2022/11/10/aller1011.jpg\" data-defer=\"view\" alt=\" logo\" loading=\"lazy\" class=\"lazyload\"/></div><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Elleville priser!\" alt=\"Image: Elleville priser!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/80571415.jpg?imageId=80571415&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inhdgd title dynamic-sizing\">Elleville</span><span class=\"x__pt8tzk-0 epYOIN title dynamic-sizing\">priser!</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 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Grøsser av Meghan\" href=\"https://www.dagbladet.no/kjendis/grosser-av-meghan/80578179\"><figure class=\"x__sc-1an7vu1-0 bpzRVX\"><picture><img data-defer=\"view\" title=\"Image: - Grøsser av Meghan\" alt=\"Image: - Grøsser av Meghan\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=73701981&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=18.571428571429&amp;panox=0&amp;heighty=0&amp;heightx=59.090909090909&amp;heightw=34.090909090909&amp;heighth=83.522727272727&amp;width=402&amp;height=325\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 criDNb title dynamic-sizing\">- Grøsser</span><span class=\"x__pt8tzk-0 emaxbb title dynamic-sizing\">av Meghan</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"I sorg\" href=\"https://www.dagbladet.no/sport/i-sorg/80580362\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: I sorg\" alt=\"Image: I sorg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80580865&amp;panox=18.367346938776&amp;panoy=13.502109704641&amp;panow=60.738581341108&amp;panoh=15.049226582278&amp;heightw=81.957187155963&amp;heighty=0&amp;heightx=11.009174311927&amp;heighth=97.555556&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gjEbOi title dynamic-sizing\">I sorg</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Nektet å krige - døde\" href=\"https://www.dagbladet.no/nyheter/nektet-a-krige-dode/80585499\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Nektet å krige - døde\" alt=\"Image: Nektet å krige - døde\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80585508&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hXgjw title dynamic-sizing\">Nektet å</span><span class=\"x__pt8tzk-0 jPnLUB title dynamic-sizing\">krige - døde</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russiske kvinner kritiserer Putin\" href=\"https://www.dagbladet.no/nyheter/russiske-kvinner-kritiserer-putin/80584315\"><figure class=\"x__sc-1an7vu1-0 qUoPe\"><picture><img data-defer=\"view\" title=\"Image: Russiske kvinner kritiserer Putin\" alt=\"Image: Russiske kvinner kritiserer Putin\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80584320&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=402&amp;height=425\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Russiske kvinner</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">kritiserer Putin</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-smartbanner2\" class=\"adunit-wrapper columns small-12 medium-12 large-12 track-element  \" data-from=\"xavier\"><div id=\"ad-smartbanner2\" class=\"adunit GoogleActiveViewElement small-980xauto medium-980xauto large-980xauto\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[980,600],[980,300],[970,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"true\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;smartbanner2&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Total  galskap\" href=\"https://www.dagbladet.no/kjendis/total-galskap/80581629\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Total  galskap\" alt=\"Image: - Total  galskap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80582273&amp;panox=0&amp;panow=100&amp;panoh=30.084745762712&amp;panoy=28.389830508475&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=68.702290076336&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 eCHIew title dynamic-sizing\">- Total</span><span class=\"x__pt8tzk-0 ggbHpa title dynamic-sizing\"> galskap</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Drept med samuraisverd\" href=\"https://www.dagbladet.no/nyheter/drept-med-samuraisverd/80581129\"><figure class=\"x__sc-1an7vu1-0 bbUhCo\"><picture><img data-defer=\"view\" title=\"Image: Drept med samuraisverd\" alt=\"Image: Drept med samuraisverd\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80581748&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=347\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kukeCs title dynamic-sizing\">Drept med</span><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">samuraisverd</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Stygge rykter\" href=\"https://www.dagbladet.no/sport/stygge-rykter/80578139\"><figure class=\"x__sc-1an7vu1-0 kaatHb\"><picture><img data-defer=\"view\" title=\"Image: Stygge rykter\" alt=\"Image: Stygge rykter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80578979&amp;panoy=18.041237113402&amp;panox=28.00453537415&amp;panow=71.99546462585&amp;panoh=37.457044329897&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=385\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Stygge rykter</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Disputt: - Knallharde diskusjoner\" href=\"https://www.dagbladet.no/sport/disputt-knallharde-diskusjoner/80580110\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Disputt: - Knallharde diskusjoner\" alt=\"Image: Disputt: - Knallharde diskusjoner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80580121&amp;panox=0&amp;panow=100&amp;panoh=50.714285714286&amp;panoy=10.714285714286&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">Disputt: - Knallharde</span><span class=\"x__pt8tzk-0 dQSCBR title dynamic-sizing\">diskusjoner</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ekspert: - Vær forsiktig med dette\" href=\"https://www.dagbladet.no/video/ekspert-kan-ta-skade/6ZGdqMXR\"><figure class=\"x__sc-1an7vu1-0 gmpxUf moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Ekspert: - Vær forsiktig med dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/80564069.jpg?imageId=80564069&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=178\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/11/20/7d2f589a-4296-47bc-a07a-4e3e9d9330b1/gif_1.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/11/20/7d2f589a-4296-47bc-a07a-4e3e9d9330b1/gif_1.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 erpCho title dynamic-sizing\">Ekspert: - Vær</span><span class=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">forsiktig med dette</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=\"- Mamma har yngre mann\" href=\"https://www.dagbladet.no/tema/mamma-har-yngre-mann/80473578\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Mamma har yngre mann\" alt=\"Image: - Mamma har yngre mann\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80473614&amp;panox=0&amp;panow=100&amp;panoh=22.62996941896&amp;panoy=25.688073394495&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iITVJY title dynamic-sizing\">- Mamma har</span><span class=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">yngre mann</span></h3></header></a></article><div id=\"apos-medium-rectangle4\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle4\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle4&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Vet ikke så mye\" href=\"https://www.dagbladet.no/sport/vet-ikke-sa-mye/80584454\"><figure class=\"x__sc-1an7vu1-0 dXDHws\"><picture><img data-defer=\"view\" title=\"Image: - Vet ikke så mye\" alt=\"Image: - Vet ikke så mye\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80584498&amp;panox=0&amp;panoy=5.7142857142857&amp;panow=97.352025233645&amp;panoh=29.115646530612&amp;heighty=0&amp;heightx=6.25&amp;heightw=69.7916671875&amp;heighth=99.546485714286&amp;width=485&amp;height=490\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">- Vet ikke så mye</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ny studie: Kobles til Alzheimers\" href=\"https://www.dagbladet.no/nyheter/ny-studie-kobles-til-alzheimers/80556793\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Ny studie: Kobles til Alzheimers\" alt=\"Image: Ny studie: Kobles til Alzheimers\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80564723&amp;panox=0&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hIOHzH title dynamic-sizing\">Ny studie:</span><span class=\"x__pt8tzk-0 bxkUEU title dynamic-sizing\">Kobles til</span><span class=\"x__pt8tzk-0 eQoVaS title dynamic-sizing\">Alzheimers</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slutt å snakk ned yrket mitt\" href=\"https://www.dagbladet.no/meninger/slutt-a-snakk-ned-yrket-mitt/80581472\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Slutt å snakk ned yrket mitt\" alt=\"Image: Slutt å snakk ned yrket mitt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80582102&amp;panoh=64.343436363636&amp;panoy=24.760818181818&amp;panox=0&amp;panow=99.893674641148&amp;heighth=99.847794520548&amp;heighty=0.15220547945205&amp;heightx=33.695652173913&amp;heightw=32.52818115942&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><div class=\"meninger\" style=\"padding:5px\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\" viewBox=\"0 0 24 24\" fill=\"#579090\" stroke=\"#579090\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-circle\"><circle cx=\"12\" cy=\"12\" r=\"10\"></circle></svg><span class=\"meninger-text\">MENINGER</span></div></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">Slutt å snakk</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">ned yrket mitt</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"meninger\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tesla må tape\" href=\"https://www.dagbladet.no/meninger/tesla-ma-tape/80582567\"><figure class=\"x__sc-1an7vu1-0 cgnnAR\"><picture><img data-defer=\"view\" title=\"Image: Tesla må tape\" alt=\"Image: Tesla må tape\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80205387&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighth=100.32467532468&amp;heightw=40.73275862069&amp;heighty=0.32467532467532&amp;heightx=44.827586206897&amp;width=485&amp;height=322\" 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=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">Tesla må tape</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard6\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard6\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kaller meg dårlig far\" href=\"https://www.dagbladet.no/tema/dennis-poppesvarer-pa-ryktene/80389265\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Kaller meg dårlig far\" alt=\"Image: - Kaller meg dårlig far\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80390866&amp;panoy=29.325513196481&amp;panox=29.708737864078&amp;panow=41.006178252427&amp;panoh=21.16768856305&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">- Kaller meg</span><span class=\"x__pt8tzk-0 bkgkdp title dynamic-sizing\">dårlig far</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=\"Intim-sjokk\" href=\"https://www.dagbladet.no/video/intim-sjokk/j9xtvdi2\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Intim-sjokk\" alt=\"Image: Intim-sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/j9xtvdi2-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=\"x__pt8tzk-0 kNhGgX title dynamic-sizing\">Intim-sjokk</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ut mot Norge\" href=\"https://www.dagbladet.no/sport/snakker-for-mye/80569653\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Ut mot Norge\" alt=\"Image: Ut mot Norge\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80574989&amp;panox=0&amp;panow=99.968701408451&amp;panoh=51.361502816901&amp;panoy=7.7464788732394&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 SXEmE title dynamic-sizing\">Ut mot Norge</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Svensk slakt: - Idioter\" href=\"https://www.dagbladet.no/sport/svensk-slakt-idioter/80579736\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Svensk slakt: - Idioter\" alt=\"Image: Svensk slakt: - Idioter\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80579772&amp;panow=99.968701408451&amp;panoh=25.680751408451&amp;panoy=28.169014084507&amp;panox=0.031298591549295&amp;heightw=82.241888495575&amp;heighty=0&amp;heightx=4.4247787610619&amp;heighth=99.955850331126&amp;width=402&amp;height=201\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hsPeia title dynamic-sizing\">Svensk slakt:</span><span class=\"x__pt8tzk-0 jfcAvK title dynamic-sizing\">- Idioter</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Hamas: - Vi finner ikke gislene\" href=\"https://www.dagbladet.no/nyheter/hamas-vi-finner-ikke-gislene-1/80578571\"><figure class=\"x__sc-1an7vu1-0 dRaWNy\"><picture><img data-defer=\"view\" title=\"Image: Hamas: - Vi finner ikke gislene\" alt=\"Image: Hamas: - Vi finner ikke gislene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80578960&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=100&amp;heighth=100&amp;heightx=0&amp;width=402&amp;height=305\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">Hamas: - Vi finner</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">ikke gislene</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Innrømmer: - Føles litt meningsløst\" href=\"https://www.dagbladet.no/kjendis/innrommer-foles-litt-meningslost/80568776\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Innrømmer: - Føles litt meningsløst\" alt=\"Image: Innrømmer: - Føles litt meningsløst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80568825&amp;panoy=22.131147540984&amp;panox=22.108843537415&amp;panow=71.99546462585&amp;panoh=19.854280327869&amp;heightw=38.841807627119&amp;heighth=50.566893197279&amp;heighty=12.925170068027&amp;heightx=34.745762711864&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jdcGMN title dynamic-sizing\">Innrømmer: - Føles</span><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">litt meningsløst</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=\"Test av kjøkkenmaskiner: - Terningkast seks!\" href=\"https://www.dagbladet.no/tema/test-av-kjokkenmaskiner-terningkast-seks/80526241\"><figure class=\"x__sc-1an7vu1-0 lcWYHB\"><picture><img data-defer=\"view\" title=\"Image: Test av kjøkkenmaskiner: - Terningkast seks!\" alt=\"Image: Test av kjøkkenmaskiner: - Terningkast seks!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80551846&amp;panox=0.1073536231884&amp;panow=100.10735362319&amp;panoh=50.885668115942&amp;panoy=26.811594202899&amp;heighty=0.15325655172413&amp;heightx=30.733944954128&amp;heightw=40.927624770642&amp;heighth=100.15325655172&amp;width=320&amp;height=202\" 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=\"x__pt8tzk-0 hpQSgl title dynamic-sizing\">Test av kjøkkenmaskiner:</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">- Terningkast seks!</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-black\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russland: Voldsom eksplosjon\" href=\"https://www.dagbladet.no/video/russland-voldsom-eksplosjon/H9te2we7\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Russland: Voldsom eksplosjon\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/80580158.jpg?imageId=80580158&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/11/26/f7d80882-81c6-4c14-a35a-37430838af3e/russlandeksplosjon2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/11/26/f7d80882-81c6-4c14-a35a-37430838af3e/russlandeksplosjon2.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kwLuaB title dynamic-sizing\">Russland: Voldsom</span><span class=\"x__pt8tzk-0 inksEV title dynamic-sizing\">eksplosjon</span></h3></header></a></article><div id=\"apos-medium-rectangle5\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle5\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle5&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Farligste på flere tiår\" href=\"https://www.dagbladet.no/nyheter/farligste-pa-flere-tiar/80582399\"><figure class=\"x__sc-1an7vu1-0 jBzAwk\"><picture><img data-defer=\"view\" title=\"Image: - Farligste på flere tiår\" alt=\"Image: - Farligste på flere tiår\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80582406&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=272\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jPnLUB title dynamic-sizing\">- Farligste</span><span class=\"x__pt8tzk-0 hQxAYP title dynamic-sizing\">på flere tiår</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Det er helt grusomt\" href=\"https://www.dagbladet.no/kjendis/det-er-helt-grusomt/80582475\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Det er helt grusomt\" alt=\"Image: - Det er helt grusomt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80582764&amp;panow=100&amp;panoy=8.1911262798635&amp;panox=0&amp;panoh=24.232081911263&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 kmfDed title dynamic-sizing\">- Det er</span><span class=\"x__pt8tzk-0 jtCXvA title dynamic-sizing\">helt grusomt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer vulkan-evakuerte\" href=\"https://www.dagbladet.no/nyheter/advarer-vulkan-evakuerte/80579633\"><figure class=\"x__sc-1an7vu1-0 kbNwpF\"><picture><img data-defer=\"view\" title=\"Image: Advarer vulkan-evakuerte\" alt=\"Image: Advarer vulkan-evakuerte\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80580026&amp;panoy=41.271455696203&amp;panow=100&amp;panoh=44.936708860759&amp;panox=0&amp;heighty=0&amp;heightx=43.367346938776&amp;heightw=45.918367346939&amp;heighth=100&amp;width=402&amp;height=282\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cUXKOF title dynamic-sizing\">Advarer</span><span class=\"x__pt8tzk-0 jEhvtw title dynamic-sizing\">vulkan-evakuerte</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Forventer store mengder nordlys\" href=\"https://www.dagbladet.no/nyheter/forventer-store-mengder-nordlys/80580130\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Forventer store mengder nordlys\" alt=\"Image: Forventer store mengder nordlys\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80579212&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;panow=100&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gApunH title dynamic-sizing\">Forventer store</span><span class=\"x__pt8tzk-0 cGLrSG title dynamic-sizing\">mengder nordlys</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard7\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard7\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Til sykehus: - Den er massiv!\" href=\"https://www.dagbladet.no/video/til-sykehus-den-er-massiv/96lIuUgf\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Til sykehus: - Den er massiv!\" alt=\"Image: Til sykehus: - Den er massiv!\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/96lIuUgf-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=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Til sykehus:</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">- Den er massiv!</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=\"Kåring: Årets lag i OBOS-ligaen\" href=\"https://www.dagbladet.no/sport/karing-arets-lag-i-obos-ligaen/80557634\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Kåring: Årets lag i OBOS-ligaen\" alt=\"Image: Kåring: Årets lag i OBOS-ligaen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80557724&amp;panoy=7.1942446043165&amp;panox=0.16025673076923&amp;panow=100.16025673077&amp;panoh=51.318945323741&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">Kåring: Årets</span><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">lag i OBOS-ligaen</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Ekspertene måper: - Elsket ham\" href=\"https://www.dagbladet.no/sport/ekspertene-maper-elsket-ham/80584220\"><figure class=\"x__sc-1an7vu1-0 hTZISu\"><picture><img data-defer=\"view\" title=\"Image: Ekspertene måper: - Elsket ham\" alt=\"Image: Ekspertene måper: - Elsket ham\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80584801&amp;panoy=0&amp;panox=0&amp;panow=100.08658&amp;panoh=48.444173154362&amp;heightw=43.566095652174&amp;heighth=100.12368571429&amp;heighty=0&amp;heightx=0&amp;width=485&amp;height=310\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 jiGVVj title dynamic-sizing\">Ekspertene måper:</span><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">- Elsket ham</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Engelsk TV: Nådeløst\" href=\"https://www.dagbladet.no/sport/engelsk-tv-nadelost-1/80585466\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: Engelsk TV: Nådeløst\" alt=\"Image: Engelsk TV: Nådeløst\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80585486&amp;panow=100.16025673077&amp;panoy=4.8582995951417&amp;panox=0.16025673076923&amp;panoh=28.879892307692&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=485&amp;height=242\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 inhdgd title dynamic-sizing\">Engelsk TV:</span><span class=\"x__pt8tzk-0 bWzzkU title dynamic-sizing\">Nådeløst</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=\"Studie: Rett behandling av Hallux valgus\" href=\"https://www.dagbladet.no/tema/studie-rett-behandling-av-hallux-valgus/80551091\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Studie: Rett behandling av Hallux valgus\" alt=\"Image: Studie: Rett behandling av Hallux valgus\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80557818&amp;panoy=55.714285714286&amp;panow=100&amp;panoh=33.809523809524&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=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">Studie: Rett</span><span class=\"x__pt8tzk-0 dfserP title dynamic-sizing\">behandling av</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Hallux valgus</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=\"Lofoten: Dukket opp på pornonettsted\" href=\"https://www.dagbladet.no/video/lofoten-dukket-opp-pa-pornonettsted/crTaKq5M\"><figure class=\"x__sc-1an7vu1-0 fnBKjt\"><picture><img data-defer=\"view\" title=\"Image: Lofoten: Dukket opp på pornonettsted\" alt=\"Image: Lofoten: Dukket opp på pornonettsted\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/crTaKq5M-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=\"x__pt8tzk-0 iNHyie title dynamic-sizing\">Lofoten: Dukket opp</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">på pornonettsted</span></h3></header></a></article><div id=\"apos-medium-rectangle6\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle6\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle6&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Dette er årets julekalendere\" href=\"https://www.dagbladet.no/kultur/dette-er-arets-julekalendere/80586439\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: Dette er årets julekalendere\" alt=\"Image: Dette er årets julekalendere\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80587100&amp;panow=88.841608510638&amp;panoh=53.21637593985&amp;panoy=11.278195488722&amp;panox=0&amp;heighth=83.301588571429&amp;heighty=3.4285714285714&amp;heightx=16.181229773463&amp;heightw=29.054297734628&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">Dette er årets</span><span class=\"x__pt8tzk-0 dWzMnA title dynamic-sizing\">julekalendere</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Turistadvarsel: - Lagres i kloakken\" href=\"https://www.dagbladet.no/nyheter/turistadvarsel-lagres-i-kloakken/80570959\"><figure class=\"x__sc-1an7vu1-0 hGMNlK\"><picture><img data-defer=\"view\" title=\"Image: Turistadvarsel: - Lagres i kloakken\" alt=\"Image: Turistadvarsel: - Lagres i kloakken\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80571677&amp;panow=100&amp;panoy=0&amp;panox=0&amp;panoh=100&amp;heightx=17.647058823529&amp;heightw=40.723981900452&amp;heighth=100&amp;heighty=0&amp;width=402&amp;height=361\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">Turistadvarsel:</span><span class=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">- Lagres i kloakken</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard8\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard8\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Tror russerne overgir seg\" href=\"https://www.dagbladet.no/video/tror-russerne-overgir-seg/0H3UEIc3\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Tror russerne overgir seg\" alt=\"Image: Tror russerne overgir seg\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/0H3UEIc3-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=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Tror russerne</span><span class=\"x__pt8tzk-0 bWSnVS title dynamic-sizing\">overgir seg</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=\"Syk eller ufør: Gjør dette nå\" href=\"https://www.dagbladet.no/tema/syk-eller-ufor-gjor-dette-na/80369730\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Syk eller ufør: Gjør dette nå\" alt=\"Image: Syk eller ufør: Gjør dette nå\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80383229&amp;panoy=42.380952380952&amp;panow=66.27866031746&amp;panoh=33.703704761905&amp;panox=0&amp;heighth=99.847794520548&amp;heighty=0.15220547945205&amp;heightx=10.502283105023&amp;heightw=40.994420091324&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=\"x__pt8tzk-0 dfserP title dynamic-sizing\">Syk eller ufør:</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">Gjør dette nå</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Avslører Frimurerlosjen: - Påtrengende\" href=\"https://www.dagbladet.no/tema/avslorer-frimurerlosjens-hemmeligheter/80448631\"><figure class=\"x__sc-1an7vu1-0 jDKzJI\"><picture><img data-defer=\"view\" title=\"Image: Avslører Frimurerlosjen: - Påtrengende\" alt=\"Image: Avslører Frimurerlosjen: - Påtrengende\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80472173&amp;panoy=0&amp;panow=100&amp;panoh=100&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=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=\"x__pt8tzk-0 beDNpZ title dynamic-sizing\">Avslører Frimurerlosjen:</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">- Påtrengende</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=\"- Har gått for langt\" href=\"https://www.dagbladet.no/video/-har-gatt-for-langt/H2UhH3lJ\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Har gått for langt\" alt=\"Image: - Har gått for langt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/H2UhH3lJ-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=\"x__pt8tzk-0 cJcNIn title dynamic-sizing\">- Har gått</span><span class=\"x__pt8tzk-0 beQydf title dynamic-sizing\">for langt</span></h3></header></a></article><div id=\"apos-medium-rectangle7\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle7\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle7&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Kjenner ham ikke igjen\" href=\"https://www.dagbladet.no/kjendis/kjenner-ham-ikke-igjen/80578077\"><figure class=\"x__sc-1an7vu1-0 fnQDHb\"><picture><img data-defer=\"view\" title=\"Image: - Kjenner ham ikke igjen\" alt=\"Image: - Kjenner ham ikke igjen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80577365&amp;panoy=7.909604519774&amp;panox=10.526315789474&amp;panow=78.947368421053&amp;panoh=40.112994350282&amp;heightw=27.027027027027&amp;heighth=66.216216216216&amp;heightx=37.537537537538&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=\"x__pt8tzk-0 dBWQRi title dynamic-sizing\">- Kjenner ham</span><span class=\"x__pt8tzk-0 ldTjgH title dynamic-sizing\">ikke igjen</span></h3></header></a></article><article class=\"preview columns small-6 medium-6 large-6\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advarer etter dette: - Sykt vondt\" href=\"https://www.dagbladet.no/nyheter/advarer-etter-dette-sykt-vondt/80574213\"><figure class=\"x__sc-1an7vu1-0 gMRBUJ\"><picture><img data-defer=\"view\" title=\"Image: Advarer etter dette: - Sykt vondt\" alt=\"Image: Advarer etter dette: - Sykt vondt\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80574226&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;panox=0&amp;heighth=100&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;width=485&amp;height=290\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hPDIHE title dynamic-sizing\">Advarer etter</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">dette: - Sykt vondt</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Bombet av vårt eget fly\" href=\"https://www.dagbladet.no/video/-bombet-av-vart-eget-fly/trmJwP6j\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Bombet av vårt eget fly\" alt=\"Image: - Bombet av vårt eget fly\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/trmJwP6j-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=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">- Bombet av</span><span class=\"x__pt8tzk-0 dyaAfc title dynamic-sizing\">vårt eget fly</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=\"Åpner om sjokket: - Våknet som enke\" href=\"https://www.dagbladet.no/kultur/apner-om-sjokket-vaknet-som-enke/80483340\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Åpner om sjokket: - Våknet som enke\" alt=\"Image: Åpner om sjokket: - Våknet som enke\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80483373&amp;panoy=13.382899628253&amp;panox=0&amp;panow=100&amp;panoh=26.39405204461&amp;heightx=15.753424657534&amp;heightw=61.643835616438&amp;heighth=79.032258064516&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=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Åpner om sjokket:</span><span class=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">- Våknet som enke</span></h3></header></a></article></div></div><div id=\"apos-netboard9\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard9\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Raser etter sjokkscener\" href=\"https://www.dagbladet.no/sport/raser-etter-sjokkscener/80581406\"><figure class=\"x__sc-1an7vu1-0 hGQBlC\"><picture><img data-defer=\"view\" title=\"Image: Raser etter sjokkscener\" alt=\"Image: Raser etter sjokkscener\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80581871&amp;panoy=6.9444444444444&amp;panow=100&amp;panoh=49.305555555556&amp;panox=0&amp;heighty=0&amp;heightx=27.102803738318&amp;heightw=42.056074766355&amp;heighth=100&amp;width=402&amp;height=230\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 Uccen title dynamic-sizing\">Raser etter</span><span class=\"x__pt8tzk-0 iXjdLY title dynamic-sizing\">sjokkscener</span></h3></header></a></article><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Utrolig rart\" href=\"https://www.dagbladet.no/kjendis/utrolig-rart/80581169\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Utrolig rart\" alt=\"Image: - Utrolig rart\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80581297&amp;panoh=17.021276595745&amp;panoy=16.312056737589&amp;panox=17.549668874172&amp;panow=69.867549668874&amp;heightx=32.407407407407&amp;heightw=41.666666666667&amp;heighth=47.727272727273&amp;heighty=6.1688311688312&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iAWFly title dynamic-sizing\">- Utrolig rart</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=\"- Hun er singel, hun er ensom\" href=\"https://www.dagbladet.no/tema/hun-er-singel-hun-er-ensom/80410752\"><figure class=\"x__sc-1an7vu1-0 kAAGbU\"><picture><img data-defer=\"view\" title=\"Image: - Hun er singel, hun er ensom\" alt=\"Image: - Hun er singel, hun er ensom\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80220677&amp;panoy=19.736842105263&amp;panox=19.883040935673&amp;panow=60.591292982456&amp;panoh=30.799220175439&amp;heightx=42.608695652174&amp;heightw=25.861513623188&amp;heighth=63.140096521739&amp;heighty=15.217391304348&amp;width=320&amp;height=183\" 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=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">- Hun er singel,</span><span class=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">hun er ensom</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-yellow\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Omringes - så skjer dette\" href=\"https://www.dagbladet.no/video/undervurderer-bjornen/4aWd2W2F\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Omringes - så skjer dette\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/80580572.jpg?imageId=80580572&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2022/01/11/c6d0b7af-9cdd-4a2f-a95c-de27305e99a3/bjoern_vs_ulv_gif.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2022/01/11/c6d0b7af-9cdd-4a2f-a95c-de27305e99a3/bjoern_vs_ulv_gif.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 ijicdz title dynamic-sizing\">Omringes - så</span><span class=\"x__pt8tzk-0 kMqJSM title dynamic-sizing\">skjer dette</span></h3></header></a></article><div id=\"apos-medium-rectangle8\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle8\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle8&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-7 medium-7 large-7\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Savner Solskjær\" href=\"https://www.dagbladet.no/sport/savner-solskjaer/80581822\"><figure class=\"x__sc-1an7vu1-0 kviAry\"><picture><img data-defer=\"view\" title=\"Image: - Savner Solskjær\" alt=\"Image: - Savner Solskjær\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80583418&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;width=567&amp;height=283\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iWZcdV title dynamic-sizing\">- Savner</span><span class=\"x__pt8tzk-0 inoUtg title dynamic-sizing\">Solskjær</span></h3></header></a></article><article class=\"preview columns small-5 medium-5 large-5\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"dagbladet-model-front\" data-label=\"\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Behandler «Bamsegutt»-klager\" href=\"https://www.dagbladet.no/nyheter/behandler-bamsegutt-klager/80582456\"><figure class=\"x__sc-1an7vu1-0 gtMzqw\"><picture><img data-defer=\"view\" title=\"Image: Behandler «Bamsegutt»-klager\" alt=\"Image: Behandler «Bamsegutt»-klager\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80586347&amp;panox=25.071225071225&amp;panow=62.108262108262&amp;panoh=31.896551724138&amp;panoy=4.7413793103448&amp;heightx=26.598465473146&amp;heighty=2.2988505747126&amp;heightw=24.040920716113&amp;heighth=58.620689655172&amp;width=402&amp;height=441\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 dfgvpn title dynamic-sizing\">Behandler</span><span class=\"x__pt8tzk-0 fNDhDy title dynamic-sizing\">«Bamsegutt»-klager</span></h3></header></a></article></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard10\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard10\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Russisk turist herjer i gatene\" href=\"https://www.dagbladet.no/video/russisk-turist-herjer-i-gatene/2aCLShI3\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Russisk turist herjer i gatene\" alt=\"Image: Russisk turist herjer i gatene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/2aCLShI3-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=\"x__pt8tzk-0 epoJzD title dynamic-sizing\">Russisk turist</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">herjer i gatene</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=\"Små tegn: Utro på julebordet\" href=\"https://www.dagbladet.no/tema/sma-tegn-utro-pa-julebordet/80507137\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Små tegn: Utro på julebordet\" alt=\"Image: Små tegn: Utro på julebordet\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80520912&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heighty=0&amp;heightw=40.723981900452&amp;heighth=100&amp;heightx=11.764705882353&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=\"x__pt8tzk-0 iFlEmK title dynamic-sizing\">Små tegn: Utro</span><span class=\"x__pt8tzk-0 gPIxea title dynamic-sizing\">på julebordet</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Uførefelle: Kan gå glipp av millioner\" href=\"https://www.dagbladet.no/tema/advarer-mot-ukjent-uforefelle/80435592\"><figure class=\"x__sc-1an7vu1-0 hWqjha\"><picture><img data-defer=\"view\" title=\"Image: Uførefelle: Kan gå glipp av millioner\" alt=\"Image: Uførefelle: Kan gå glipp av millioner\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80435642&amp;panox=0&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panoy=14.893617021277&amp;heighty=0.22371409395974&amp;heightx=34.080717488789&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;width=320&amp;height=248\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 iYgBvA title dynamic-sizing\">Uførefelle: Kan gå</span><span class=\"x__pt8tzk-0 kVJNPR title dynamic-sizing\">glipp av millioner</span></h3></header></a></article><article class=\"preview columns small-4 medium-4 large-4 bg-red\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Regelen er genial\" href=\"https://www.dagbladet.no/video/tabbe-kan-forarsake-fuktskade/hGnN5YFw\"><figure class=\"x__sc-1an7vu1-0 fjJyvE moving-image-container\"><video muted=\"\" loop=\"\" data-video-defer=\"view\" preload=\"none\" title=\"Image: Regelen er genial\" class=\"moving-image\" playsinline=\"\" poster=\"https://www.dagbladet.no/images/80578614.jpg?imageId=80578614&amp;x=0.000000&amp;y=0.000000&amp;cropw=100.000000&amp;croph=79.891304&amp;width=320&amp;height=160\" disableremoteplayback=\"\"><source src=\"https://snipp.dbstatic.no/2023/11/24/7ee34674-69fa-4129-b9ec-d3ffff04db30/gulvvask_gif_2.webm\" type=\"video/webm\"/><source src=\"https://snipp.dbstatic.no/2023/11/24/7ee34674-69fa-4129-b9ec-d3ffff04db30/gulvvask_gif_2.mp4\" type=\"video/mp4\"/></video><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 hrVcDN title dynamic-sizing\">Regelen</span><span class=\"x__pt8tzk-0 jGSTdz title dynamic-sizing\">er genial</span></h3></header></a></article><div id=\"apos-medium-rectangle9\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle9\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle9&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div id=\"apos-netboard11\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard11\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"video-metapop-model\" data-label=\"video\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"- Fører til at badet må rives\" href=\"https://www.dagbladet.no/video/-forer-til-at-badet-ma-rives/8ytm3D5G\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Fører til at badet må rives\" alt=\"Image: - Fører til at badet må rives\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/8ytm3D5G-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=\"x__pt8tzk-0 fIeyCx title dynamic-sizing\">- Fører til at</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">badet må rives</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=\"Anders&#x27; nye kropp: Fettprosenten raste\" href=\"https://www.dagbladet.no/tema/anders-nye-kropp-fettprosenten-raste/80402623\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Anders&#x27; nye kropp: Fettprosenten raste\" alt=\"Image: Anders&#x27; nye kropp: Fettprosenten raste\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80408755&amp;panow=47.419272768879&amp;panoh=84.605086746988&amp;panoy=2.4096385542169&amp;panox=27.002288329519&amp;heightx=51.417004048583&amp;heightw=11.808367071525&amp;heighth=100.34965034965&amp;heighty=0.34965034965035&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=\"x__pt8tzk-0 cyVXzf title dynamic-sizing\">Anders&#x27; nye kropp:</span><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Fettprosenten raste</span></h3></header></a></article></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Slik blir du kvitt mannebrystene\" href=\"https://www.dagbladet.no/tema/slik-blir-du-kvitt-mannebrystene/80505933\"><figure class=\"x__sc-1an7vu1-0 gzqAYE\"><picture><img data-defer=\"view\" title=\"Image: Slik blir du kvitt mannebrystene\" alt=\"Image: Slik blir du kvitt mannebrystene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80511280&amp;panox=0&amp;panow=100&amp;panoh=100&amp;panoy=0&amp;heighty=0&amp;heightx=55.156950672646&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;width=320&amp;height=214\" 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=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">Slik blir du kvitt</span><span class=\"x__pt8tzk-0 jfvMWJ title dynamic-sizing\">mannebrystene</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=\"- Fullstendig galskap\" href=\"https://www.dagbladet.no/video/-fullstendig-galskap/IZRXGL9T\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: - Fullstendig galskap\" alt=\"Image: - Fullstendig galskap\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/IZRXGL9T-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=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">- Fullstendig</span><span class=\"x__pt8tzk-0 iyrywY title dynamic-sizing\">galskap</span></h3></header></a></article><div id=\"apos-medium-rectangle10\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle10\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle10&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><div class=\"xavier columns small-4 medium-4 large-4\"><div class=\"row xrow flex-column\"><article class=\"preview columns small-12 medium-12 large-12\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Advokaten forteller: Familiens testament-sjokk\" href=\"https://www.dagbladet.no/tema/advokaten-forteller-familiens-testament-sjokk/80394936\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Advokaten forteller: Familiens testament-sjokk\" alt=\"Image: Advokaten forteller: Familiens testament-sjokk\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80402080&amp;panoy=0&amp;panox=0&amp;panow=100&amp;panoh=100&amp;heightx=0&amp;heightw=100&amp;heighth=100&amp;heighty=0&amp;width=320&amp;height=160\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAJCAYAAAA7KqwyAAAAF0lEQVR42mN8++b9fwYKAOOoAaMGAAEA4ukiCUCbW0cAAAAASUVORK5CYII=\"/></picture><div class=\"figure-logo\"><div class=\"logo\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"3\"><line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 cFtCN title dynamic-sizing\">Advokaten forteller:</span><span class=\"x__pt8tzk-0 jRIgeY title dynamic-sizing\">Familiens testament-sjokk</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=\"Bør ikke settes på igjen\" href=\"https://www.dagbladet.no/video/bor-ikke-settes-pa-igjen/coL3GZ5x\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: Bør ikke settes på igjen\" alt=\"Image: Bør ikke settes på igjen\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/78971469.jpg?imageId=78971469&amp;x=0.000000&amp;y=0.000000&amp;cropw=0.000000&amp;croph=0.000000&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=\"currentColor\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"feather feather-play\"><polygon points=\"5 3 19 12 5 21 5 3\"></polygon></svg></div></div></figure><header><h3 class=\"xavier-headline headline\"><span class=\"x__pt8tzk-0 gRLJwN title dynamic-sizing\">Bør ikke</span><span class=\"x__pt8tzk-0 jdgMzU title dynamic-sizing\">settes på igjen</span></h3></header></a></article></div></div><div id=\"apos-netboard12\" class=\"adunit-wrapper columns small-8 medium-8 large-8 track-element  \" data-from=\"xavier\"><div id=\"ad-netboard12\" class=\"adunit GoogleActiveViewElement small-580x500 medium-580x500 large-580x500\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[580,400],[580,500],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;netboard12&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div><div class=\"row xrow flex-initial\"><article class=\"preview columns small-4 medium-4 large-4\" data-cxense_tag=\"cerebro\" data-cxence_widget=\"pluss-model-front\" data-label=\"pluss\" data-from=\"xavier\" data-reverseImageTextOrder=\"false\"><a target=\"_self\" aria-label=\"Snart 62? Unngå disse fellene\" href=\"https://www.dagbladet.no/tema/snart-62-unnga-disse-fellene/80398036\"><figure class=\"x__sc-1an7vu1-0 eAYXY\"><picture><img data-defer=\"view\" title=\"Image: Snart 62? Unngå disse fellene\" alt=\"Image: Snart 62? Unngå disse fellene\" decoding=\"async\" class=\"lazyload\" data-src=\"https://www.dagbladet.no/images/?imageId=80399366&amp;panow=99.842766981132&amp;panoh=51.536642553191&amp;panoy=26.950354609929&amp;panox=0&amp;heighty=0.22371409395974&amp;heightx=7.1748878923767&amp;heightw=41.106128251121&amp;heighth=99.77628590604&amp;width=320&amp;height=188\" 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=\"x__pt8tzk-0 frzFun title dynamic-sizing\">Snart 62? Unngå</span><span class=\"x__pt8tzk-0 bwGQrt title dynamic-sizing\">disse fellene</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=\"«Shit, der omkom han!»\" href=\"https://www.dagbladet.no/video/shit-der-omkom-han/ZIUWzR4Z\"><figure class=\"x__sc-1an7vu1-0 fjJyvE\"><picture><img data-defer=\"view\" title=\"Image: «Shit, der omkom han!»\" alt=\"Image: «Shit, der omkom han!»\" decoding=\"async\" class=\"lazyload\" data-src=\"https://cdn.jwplayer.com/thumbs/ZIUWzR4Z-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=\"x__pt8tzk-0 fTAjeM title dynamic-sizing\">«Shit, der</span><span class=\"x__pt8tzk-0 iITVJY title dynamic-sizing\">omkom han!»</span></h3></header></a></article><div id=\"apos-medium-rectangle11\" class=\"adunit-wrapper columns small-4 medium-4 large-4 track-element  \" data-from=\"xavier\"><div id=\"ad-medium-rectangle11\" class=\"adunit GoogleActiveViewElement small-320x250 medium-320x250 large-320x250\" itemscope=\"\" itemType=\"https://schema.org/WPAdBlock\" data-sizes=\"[[320,250],[300,250],&quot;fluid&quot;]\" data-slot=\"/8578/dagbladet.no/forside\" data-load-on=\"view\" data-collapse=\"false\" data-expand=\"false\" data-out-of-page=\"false\" json=\"{&quot;targeting&quot;: {&quot;pos&quot;:&quot;medium-rectangle11&quot;,&quot;platform&quot;:&quot;wolverine&quot;}}\"></div></div></div>"]
Vi bryr oss om ditt personvern
Dagbladet er en del av Aller Media, som er ansvarlig for dine data. Vi bruker informasjonskapsler (cookies) og dine data til å forbedre og tilpasse tjenestene, tilbudene og annonsene våre.
Vil du vite mer om hvordan du kan endre dine innstillinger, gå til personverninnstillinger