<div>


<!DOCTYPE html>
<html lang="id" class=" js csstransitions js csstransitions"><head>
<title>NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026</title>
<link href="//securepubads.g.doubleclick.net" rel="dns-prefetch">
<link href="//asset.kompas.com" rel="dns-prefetch">
<link href="//adsimg.kompas.com" rel="dns-prefetch">
<link href="//tpc.googlesyndication.com" rel="dns-prefetch">
<link href="//cm.g.doubleclick.net" rel="dns-prefetch">
<link href="//apis.kompas.com" rel="dns-prefetch">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<meta name="viewport" content="width=device-width">
<meta content="NINJABET4D adalah situs viral slot online gampang menang yang lagi hits 2026! Provider Slot88 gacor terpercaya dengan RTP tertinggi dan pola maxwin terbukti. Deposit ringan, WD cepat, langsung cair!" name="description"/>
<meta content="ninjabet4d, ninjabet4d, ninjabet4d slot, rtp ninjabet4d, ninjabet4d alternatif, ninjabet4d login, mahjong, slot mahjong, slot gacor, slot88, mahjong slot, situs slot, situs gacor, link gacor, slot gacor hari ini, slot viral, slot gampang menang, slot online, judi slot, judi slot online, situs judi slot, situs judi slot online, link alternatif, link alternatif slot, link alternatif judi slot, link alternatif slot online, link alternatif judi slot online" name="keywords"/>
<link rel="prefetch" href="https://eventodigital.sitedoevento.pt/" as="document"/>
<link rel="amphtml" href="https://cepathokiblay31.pages.dev/" /> 
<meta name="googlebot-news" content="index, follow" />
<meta  name="googlebot" content="index, follow" />
<meta name="author" content="NINJABET4D">
<meta name="robots" content="index, follow" />
<meta name="robots" content="max-image-preview:large, max-snippet:-1, max-video-preview:-1">
<meta name="language" content="id" />
<meta name="geo.country" content="id" />
<meta http-equiv="content-language" content="In-Id" />
<meta name="geo.placename" content="Indonesia" />
<meta property="og:type" content="article" />
<meta property="og:image" content="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhP-UQjw4sbqH8D9e1yHl23h9bmQnCfsainj1Rd-nWglUkZR_iFv-mOeSw4fVf883bgN6AxA8nawcQzMMuGVibQRkc8y5ooVVmmiH_XsT7mQ81iy3SeACy4qAHxrIb2pQW86GqzZDLy5nqU81x7ahR87BSns-mSoefx_kfI8SKOufQX3-qPqfSH5J8RzyY/s1080/slotwede1.png" />
<meta property="og:title" content="NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026" />
<meta property="og:description" content="NINJABET4D adalah situs viral slot online gampang menang yang lagi hits 2026! Provider Slot88 gacor terpercaya dengan RTP tertinggi dan pola maxwin terbukti. Deposit ringan, WD cepat, langsung cair!">
<meta property="og:url" content="https://eventodigital.sitedoevento.pt/" />
<meta property="og:site_name" content="KOMPAS.com" />
<meta property="fb:app_id" content="324557847592228" />
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:site" content="@kompascom" />
<meta name="twitter:creator" content="@kompascom">
<meta name="twitter:title" content="NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026" />
<meta name="twitter:description" content="NINJABET4D adalah situs viral slot online gampang menang yang lagi hits 2026! Provider Slot88 gacor terpercaya dengan RTP tertinggi dan pola maxwin terbukti. Deposit ringan, WD cepat, langsung cair!" />
<meta name="twitter:image" content="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhP-UQjw4sbqH8D9e1yHl23h9bmQnCfsainj1Rd-nWglUkZR_iFv-mOeSw4fVf883bgN6AxA8nawcQzMMuGVibQRkc8y5ooVVmmiH_XsT7mQ81iy3SeACy4qAHxrIb2pQW86GqzZDLy5nqU81x7ahR87BSns-mSoefx_kfI8SKOufQX3-qPqfSH5J8RzyY/s1080/slotwede1.png" />
<meta name="content_category" content="NINJABET4D" />
<meta name="content_subcategory" content="NINJABET4D" />
<meta name="content_location" content="Di" />
<meta name="content_author_id" content="" />
<meta name="content_author" content="" />
<meta name="content_editor_id" content="7768" />
<meta name="content_editor" content="NINJABET4D" />
<meta name="content_lipsus" content="" />
<meta name="content_lipsus_id" content="" />
<meta name="content_sensi" content="" />
<meta name="content_type" content="Standard" />
<meta name="content_PublishedDate" content="2025-09-04 17:20:00" />
<meta property="article:published_time" content="2025-09-04T10:20:00+00:00" />
<meta name="content_source" content="" />
<meta name="content_tag" content="NINJABET4D" />
<meta name="content_tags" content="" />
<meta name="content_total_words" content="452" />
<meta name="subscription" content="False" />
<meta name="lestari_sdgs" content="" />
<meta name="content_total_pages" content="1" />
<meta name="content_current_page" content="1" />
<link rel="preload" as="image" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhP-UQjw4sbqH8D9e1yHl23h9bmQnCfsainj1Rd-nWglUkZR_iFv-mOeSw4fVf883bgN6AxA8nawcQzMMuGVibQRkc8y5ooVVmmiH_XsT7mQ81iy3SeACy4qAHxrIb2pQW86GqzZDLy5nqU81x7ahR87BSns-mSoefx_kfI8SKOufQX3-qPqfSH5J8RzyY/s1080/slotwede1.png">
<link rel="preload" href="https://securepubads.g.doubleclick.net/tag/js/gpt.js" as="script">
<link rel="icon" href="http://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjTUDMaiVsui2-b7MGUJkoCTLqlp6K4UK17rDkMyTwQINUdixWERAVAdEqrsfTWKLPHppihZmndo96nAR-HBNqHi0Xum2khxFYb_LhuZylCgtBOz6XY-bccg5kCkdY83SpcHR0GmygiCeG3GE8_3U0pOI0qZn7c-enp68SHFehtV3Fk8hahZZ7uzPgxKy8/s320/linklogin.gif" sizes="32x32"/>
<link rel="icon" href="../../wp-content/uploads/2022/11/cropped-BCI-icon-192x192.png" sizes="192x192"/>
<link rel="apple-touch-icon" href="../../wp-content/uploads/2022/11/cropped-BCI-icon-180x180.png"/>
<meta name="msapplication-TileImage" content="https://skillscenterstl.com/wp-content/uploads/2022/11/cropped-BCI-icon-270x270.png"/>
<link rel="canonical" href="https://eventodigital.sitedoevento.pt/" />
<link rel="dns-prefetch" href="twitter.com">

    <link rel="stylesheet" href="https://asset.kompas.com/data/2025/08/13/kompascom/desktop/css/kcm2017-article.min.css" type="text/css"> 
    <link rel="stylesheet" href="https://asset.kompas.com/data/2025/03/05/kompascom/desktop/css/kcm2017-iconpack-article.min.css" type="text/css">
 
<link rel="stylesheet" href="https://asset.kompas.com/data/2025/08/21/0958/kgm-verify.min.css" type="text/css">
<link rel="preload" href="https://fonts.googleapis.com/css?family=Roboto+Condensed:200,300,700|Roboto:300,300i,400,400i,500,700,700i" as="style">
<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto+Condensed:200,300,700|Roboto:300,300i,400,400i,500,700,700i">
<link rel="preconnect" href="https://scripts.jixie.media"/>

<script src="https://asset.kompas.com/data/2017/wp/js/jquery-1.12.0.min.js" type="text/javascript"></script><meta http-equiv="origin-trial" content="AlK2UR5SkAlj8jjdEc9p3F3xuFYlF6LYjAML3EOqw1g26eCwWPjdmecULvBH5MVPoqKYrOfPhYVL71xAXI1IBQoAAAB8eyJvcmlnaW4iOiJodHRwczovL2RvdWJsZWNsaWNrLm5ldDo0NDMiLCJmZWF0dXJlIjoiV2ViVmlld1hSZXF1ZXN0ZWRXaXRoRGVwcmVjYXRpb24iLCJleHBpcnkiOjE3NTgwNjcxOTksImlzU3ViZG9tYWluIjp0cnVlfQ==" /><meta http-equiv="origin-trial" content="Amm8/NmvvQfhwCib6I7ZsmUxiSCfOxWxHayJwyU1r3gRIItzr7bNQid6O8ZYaE1GSQTa69WwhPC9flq/oYkRBwsAAACCeyJvcmlnaW4iOiJodHRwczovL2dvb2dsZXN5bmRpY2F0aW9uLmNvbTo0NDMiLCJmZWF0dXJlIjoiV2ViVmlld1hSZXF1ZXN0ZWRXaXRoRGVwcmVjYXRpb24iLCJleHBpcnkiOjE3NTgwNjcxOTksImlzU3ViZG9tYWluIjp0cnVlfQ==" /><meta http-equiv="origin-trial" content="A9nrunKdU5m96PSN1XsSGr3qOP0lvPFUB2AiAylCDlN5DTl17uDFkpQuHj1AFtgWLxpLaiBZuhrtb2WOu7ofHwEAAACKeyJvcmlnaW4iOiJodHRwczovL2RvdWJsZWNsaWNrLm5ldDo0NDMiLCJmZWF0dXJlIjoiQUlQcm9tcHRBUElNdWx0aW1vZGFsSW5wdXQiLCJleHBpcnkiOjE3NzQzMTA0MDAsImlzU3ViZG9tYWluIjp0cnVlLCJpc1RoaXJkUGFydHkiOnRydWV9" /><meta http-equiv="origin-trial" content="A93bovR+QVXNx2/38qDbmeYYf1wdte9EO37K9eMq3r+541qo0byhYU899BhPB7Cv9QqD7wIbR1B6OAc9kEfYCA4AAACQeyJvcmlnaW4iOiJodHRwczovL2dvb2dsZXN5bmRpY2F0aW9uLmNvbTo0NDMiLCJmZWF0dXJlIjoiQUlQcm9tcHRBUElNdWx0aW1vZGFsSW5wdXQiLCJleHBpcnkiOjE3NzQzMTA0MDAsImlzU3ViZG9tYWluIjp0cnVlLCJpc1RoaXJkUGFydHkiOnRydWV9" /><meta http-equiv="origin-trial" content="A1S5fojrAunSDrFbD8OfGmFHdRFZymSM/1ss3G+NEttCLfHkXvlcF6LGLH8Mo5PakLO1sCASXU1/gQf6XGuTBgwAAACQeyJvcmlnaW4iOiJodHRwczovL2dvb2dsZXRhZ3NlcnZpY2VzLmNvbTo0NDMiLCJmZWF0dXJlIjoiQUlQcm9tcHRBUElNdWx0aW1vZGFsSW5wdXQiLCJleHBpcnkiOjE3NzQzMTA0MDAsImlzU3ViZG9tYWluIjp0cnVlLCJpc1RoaXJkUGFydHkiOnRydWV9" /><script src="https://securepubads.g.doubleclick.net/pagead/managed/js/gpt/m202510160101/pubads_impl.js?cb=31095331" async=""></script><link href="https://securepubads.g.doubleclick.net/pagead/managed/dict/m202510140101/gpt" rel="compression-dictionary" />
<script src="https://asset.kompas.com/data/2017/wp/js/modernizr.custom.js" type="text/javascript"></script>

<link rel="preconnect" href="https://scripts.jixie.media"/>

<script type="text/javascript">
window.jixie_o = {
	accountid: "9262bf2590d558736cac4fff7978fcb1",
	partner_cookie: 'kmps_usrid',
	external_ids: ['tdid','tdid2','ifo'],
	sha256mail_cookie:'usermail',
	ad_blocker: true,
	logbids: true,
	userprofile: true,
	sha256ph_cookie:'kmps_uphn',
};
</script>
<script async="" src="https://scripts.jixie.media/jxpublisher_3_1.min.js" type="text/javascript"></script>
 

	<script type="text/javascript">

		var keyword_data = ""
		var array_keywords = keyword_data.split(",");

		window.jixie_p = window.jixie_p || [];
		window.jixie_p.push({
			action: "visit",
			parameters:{
				itemid:"20250904172000388", 
				keywords:array_keywords,
				title:"NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026",
				description: "NINJABET4D adalah situs viral slot online gampang menang yang lagi hits 2026! Provider Slot88 gacor terpercaya dengan RTP tertinggi dan pola maxwin terbukti. Deposit ringan, WD cepat, langsung cair!",
				category: "Prov"
			}
		});
	</script>

  
<script type="text/javascript">
  var keywordBrandSafety = "NINJABET4D adalah situs viral slot online gampang menang yang lagi hits 2026! Provider Slot88 gacor terpercaya dengan RTP tertinggi dan pola maxwin terbukti. Deposit ringan, WD cepat, langsung cair!";
</script>

<!-- Start Ad Blocking Recovery Message -->
<script async="" src="https://fundingchoicesmessages.google.com/i/pub-9012468469771973?ers=1" nonce="IOvmxAasolBKwB_qzaJVMg" type="text/javascript"></script><script nonce="IOvmxAasolBKwB_qzaJVMg" type="text/javascript">(function() {function signalGooglefcPresent() {if (!window.frames['googlefcPresent']) {if (document.body) {const iframe = document.createElement('iframe'); iframe.style = 'width: 0; height: 0; border: none; z-index: -1000; left: -1000px; top: -1000px;'; iframe.style.display = 'none'; iframe.name = 'googlefcPresent'; document.body.appendChild(iframe);} else {setTimeout(signalGooglefcPresent, 0);}}}signalGooglefcPresent();})();</script>
<!-- Endof Ad Blocking Recovery Message --><!-- Start: GPT Async -->
<script async="" src="https://securepubads.g.doubleclick.net/tag/js/gpt.js" type="text/javascript"></script>


<script type="text/javascript">
	var gptadslots=[];
	var googletag = googletag || {};
	googletag.cmd = googletag.cmd || [];
	(function(){ var gads = document.createElement('script');
		gads.async = true; gads.type = 'text/javascript';
		// var useSSL = 'https:' == document.location.protocol;
		gads.src = 'https://securepubads.g.doubleclick.net/tag/js/gpt.js';
		var node = document.getElementsByTagName('script')[0];
		node.parentNode.insertBefore(gads, node);
	})();
</script> 


<script type="text/javascript">

	googletag.cmd.push(function() {

		//Adslot 1 declaration
		gptadslots[1]= googletag.defineSlot('/31800665/KOMPAS.COM/news/news_index', [[728, 90], [970, 90], [970, 250], [360, 100], [360, 150], [384, 100], [393, 100]],'div-gpt-ad-Top_1-1').setTargeting('Pos',['Top_1']).setTargeting('kg_pos', ['top_1']).addService(googletag.pubads());

dinv = googletag.defineOutOfPageSlot('/31800665/KOMPAS.COM/news/vignette', googletag.enums.OutOfPageFormat.INTERSTITIAL);
if (dinv !== null) {
         dinv.setTargeting('Pos', ['vignette']);
         dinv.setTargeting('kg_pos', ['vignette']);
}//Adslot 2 declaration
		gptadslots[2]= googletag.defineSlot('/31800665/KOMPAS.COM/news/news_index', [[300,600],[300,250],[160, 600]],'div-gpt-ad-Giant').setTargeting('Pos',['Giant']).setTargeting('kg_pos', ['giant']).addService(googletag.pubads());//Adslot 9 declaration
			gptadslots[9]= googletag.defineSlot('/31800665/KOMPAS.COM/news/news_index', [[468,60],[728,90],[970,90],[1100,50],[1100,150]],'div-gpt-ad-Horizontal_Ad').setTargeting('Pos',['Horizontal_Ad']).setTargeting('kg_pos', ['horizontal_ad']).addService(googletag.pubads());gptadslots[41121] = googletag.defineOutOfPageSlot('/31800665/KOMPAS.COM/news', 'div-gpt-for-outstream').setTargeting('Pos',['Outstream']).addService(googletag.pubads());//Adslot 8 declaration
		gptadslots[8]= googletag.defineSlot('/31800665/KOMPAS.COM/news/news_index', [[120,600],[160,600]],'div-gpt-ad-Skyscraper').setTargeting('Pos',['Skyscraper']).setTargeting('kg_pos', ['skyscraper']).addService(googletag.pubads());gptadslots[4112]= googletag.defineOutOfPageSlot('/31800665/KOMPAS.COM/news','div-gpt-ad-974648810682144181-4112').setTargeting('Pos',['native_banner_article']).setTargeting('kg_pos', ['native_banner_article']).addService(googletag.pubads());setContextualTargeting();
if(typeof keywordBrandSafety === 'undefined'){
    console.log("no article keywords");
}else{
    console.log("execute keywords");
    setKeywordTargeting();
}

function setContextualTargeting() {
    dfp_keywords = getKeywords();
    console.log(dfp_keywords);
    googletag.pubads().setTargeting('contextual_targeting', dfp_keywords);
}

function getKeywords(){
    var metas = document.getElementsByTagName('meta');
    var str = (metas.namedItem("content_tags") || {}).content;
    if (str!=null){
        var keywords = str.toLowerCase().split(",").map(function(item) {
            return item.trim().replace(/\s\s+/g, ' ');
        });
        return keywords;
    }
    return [''];
}

// s:new keyword targeting via GAM
function setKeywordTargeting() {
    dfp_keywords = getArticle();
    console.log(dfp_keywords);
    googletag.pubads().setTargeting('keyword_targeting', dfp_keywords);
}

function getArticle(){
    var strKey = keywordBrandSafety;
    if (strKey!=null){
        var keywords = strKey.toLowerCase().split(/[ .]/).map(function(item) {
            return item.trim().replace(/\W*(&amp;quot;)\W*/g, '').replace(/([^a-zA-Z0-9]$|[()\n\"])/g, '');
        });
        keywords = keywords.filter((str) => str !== '');
        return keywords;
    }
    return null;
}
// e:new keyword targeting via GAM

try{
    // Retrieving local storage
    var ls = window.localStorage;
	
	var lr = ls.getItem("_jxitr");
	if (lr && lr.length > 2){
		try{
			googletag.pubads().setTargeting('jx_audience_interest', JSON.parse(lr).join().split(','));
		}catch {}
	}
	
	var li = ls.getItem("_jxitd");
	if (li && li.length > 2){
		try{
			googletag.pubads().setTargeting('jx_audience_intend', JSON.parse(li).join().split(','));
		}catch {}
	}

}catch(e){
      //console.log("Localstorage not accessible or any other error: " + e.message);
}
if(/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)){
    googletag.pubads().setTargeting('kg_inv_type','mweb');
}else{
     googletag.pubads().setTargeting('kg_inv_type','desktop');
}
googletag.pubads().setTargeting('kg_group_sites','kompas_com');


var rl_adx_val = '';
	var rl_adx_sec = new Date().getSeconds();
	if(rl_adx_sec==1||rl_adx_sec==2){rl_adx_val='300';}
	if(rl_adx_sec==3||rl_adx_sec==4){rl_adx_val='600';}
	if(rl_adx_sec==5||rl_adx_sec==6){rl_adx_val='900';}
	if(rl_adx_sec==7||rl_adx_sec==8){rl_adx_val='1200';}
	if(rl_adx_sec==9||rl_adx_sec==10){rl_adx_val='1500';}
	if(rl_adx_sec==11||rl_adx_sec==12){rl_adx_val='1800';}
	console.log('rl_adx_val = '+rl_adx_val);
	if(rl_adx_val!=''){
	googletag.pubads().setTargeting('rl_adx',rl_adx_val);
	}googletag.pubads().setTargeting('currentUrl', '2025/09/04/172000388');googletag.pubads().setTargeting('page', 'page_1');
		

        googletag.pubads().enableSingleRequest();
        
        googletag.enableServices();
	});


</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://skillscenterstl.com/#org",
      "name": "NINJABET4D",
      "url": "https://skillscenterstl.com/",
      "logo": {
        "@type": "ImageObject",
        "url": "https://skillscenterstl.com/ast/logo.webp"
      },
      "image": [
        "https://skillscenterstl.com/ast/presiden-slot.webp",
        "https://skillscenterstl.com/ast/logo.webp",
        "https://skillscenterstl.com/wp-content/uploads/2022/11/cropped-BCI-icon-270x270.png"
      ],
      "contactPoint": [
        {
          "@type": "ContactPoint",
          "telephone": "081224365478",
          "contactType": "customer support",
          "areaServed": "ID",
          "availableLanguage": ["id", "en"]
        }
      ],
      "address": {
        "@type": "PostalAddress",
        "streetAddress": "Jl. Cempaka Putih Raya No.20, RT.1/RW.3, Cemp. Putih Bar., Kec. Cemp. Putih",
        "addressLocality": "Kota Jakarta Pusat",
        "addressRegion": "Daerah Khusus Ibukota Jakarta",
        "postalCode": "10520",
        "addressCountry": "ID"
      }
    },
    {
      "@type": "WebSite",
      "@id": "https://skillscenterstl.com/#website",
      "url": "https://skillscenterstl.com/",
      "name": "NINJABET4D",
      "publisher": { "@id": "https://skillscenterstl.com/#org" },
      "inLanguage": "id-ID"
    },
    {
      "@type": "BreadcrumbList",
      "@id": "https://eventodigital.sitedoevento.pt/#breadcrumb",
      "itemListElement": [
        {
          "@type": "ListItem",
          "position": 1,
          "name": "Slot online",
          "item": "https://eventodigital.sitedoevento.pt/"
        },
        {
          "@type": "ListItem",
          "position": 2,
          "name": "NINJABET4D",
          "item": "https://eventodigital.sitedoevento.pt/"
        }
      ]
    },
    {
      "@type": "WebPage",
      "@id": "https://eventodigital.sitedoevento.pt/#webpage",
      "url": "https://eventodigital.sitedoevento.pt/",
      "name": "NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026",
      "description": "NINJABET4D adalah agen slot online dengan min deposit hanya 5k dengan bonus harian 2026. Nikmati pilihan game dari berbagai provide dengan transaksi cepat, dan info rtp akurat 24 jam non-stop.",
      "isPartOf": { "@id": "https://skillscenterstl.com/#website" },
      "about": { "@id": "https://skillscenterstl.com/#org" },
      "breadcrumb": { "@id": "https://eventodigital.sitedoevento.pt/#breadcrumb" },
      "primaryImageOfPage": {
        "@type": "ImageObject",
        "url": "https://skillscenterstl.com/ast/presiden-slot.webp"
      },
      "inLanguage": "id-ID"
    },
    {
      "@type": "Article",
      "@id": "https://eventodigital.sitedoevento.pt/#article",
      "headline": "NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026",
      "description": "NINJABET4D adalah agen slot online dengan min deposit hanya 5k dengan bonus harian 2026. Nikmati pilihan game dari berbagai provide dengan transaksi cepat, dan info rtp akurat 24 jam non-stop.",
      "mainEntityOfPage": { "@id": "https://eventodigital.sitedoevento.pt/#webpage" },
      "publisher": { "@id": "https://skillscenterstl.com/#org" },
      "image": [
        "https://skillscenterstl.com/ast/presiden-slot.webp",
        "https://skillscenterstl.com/ast/logo.webp"
      ],
      "inLanguage": "id-ID"
    },
    {
      "@type": "SoftwareApplication",
      "@id": "https://eventodigital.sitedoevento.pt/#app",
      "name": "NINJABET4D",
      "applicationCategory": "GameApplication",
      "operatingSystem": "Android, iOS, Windows",
      "url": "https://eventodigital.sitedoevento.pt/",
      "image": "https://skillscenterstl.com/ast/presiden-slot.webp",
      "aggregateRating": {
        "@type": "AggregateRating",
        "ratingValue": 4.8,
        "ratingCount": 78588
      },
      "offers": {
        "@type": "Offer",
        "price": 0,
        "priceCurrency": "IDR",
        "availability": "https://schema.org/InStock"
      }
    }
  ]
}
</script>

<style>
.n-columns-2 {
    display: grid;
    grid-template-columns: repeat(2,1fr);
    font-weight: 700;
    }
    .n-columns-2 a {
    text-align: center;
    }
    .login, .register {
    color: #fff;
    padding: 13px 10px;
    }
    .login, .login-button {
    background: linear-gradient(to bottom, #000000 0%, #000000 100%);
    border: 2px solid #fff;
    box-shadow: 0px 0px 3px #fff;
    }
    .register, .register-button {
    background: linear-gradient(to bottom, #000000 0%, #000000 100%);
    border: 2px solid #fff;
    box-shadow: 0px 0px 3px #fff;
    }
                            </style>

<style type="text/css">
/* Avoid empty images to appear as broken */ 
img:not([src]):not([srcset]) {
  visibility: hidden;
}
/* Fix for images to never exceed the width of the container */
img {
  max-width: 100%;
}
</style>



<script type="text/javascript">
document.addEventListener('DOMContentLoaded', function() {
    var addebug = document.querySelectorAll('.footerCopyright');
    for (i = 0; i < addebug.length; ++i) {
        addebug[i].addEventListener('click', function handleClick() {
            console.log('Debugged');
            googletag.openConsole();
        });
    }
});
</script>

  <script async="" src="https://cdn.oval.id/tracker/p/kompas/oval_web_analytics_latest.js" type="text/javascript"></script>


    <script async="" src="https://fundingchoicesmessages.google.com/f/AGSKWxWpPVWc0wOaBdOgeSjsrBNExukuzyNPCtUMMTF7u6Q8RJHOp9yRJ_e8gVO4cTyS5z_Bh-fnErXkXdPTgygcOfgWayD33Tb6Yic3YlAsYiZTXN2DS1100vdLt1-pP4onwsCEZT7x7w==?fccs=W251bGwsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsLFsxNzYwNzQ1NjAwLDU3MDAwMDAwXSxudWxsLG51bGwsbnVsbCxbbnVsbCxbN11dLCJodHRwczovL3d3dy5zd2VldGxpZmVjb29raWVzYW5kY29uZmVjdGlvbnMuY29tL3Nob3AiLG51bGwsW1s4LCJkU3BSQUloYmh3TSJdLFs5LCJlbi1VUyJdLFsyNiwiNSJdLFsxOSwiMiJdLFsxNywiWzBdIl0sWzI0LCIiXSxbMjUsIltbMzEwODIyNTRdXSJdLFsyOSwiZmFsc2UiXV1d" nonce="IOvmxAasolBKwB_qzaJVMg"></script><meta http-equiv="origin-trial" content="AlK2UR5SkAlj8jjdEc9p3F3xuFYlF6LYjAML3EOqw1g26eCwWPjdmecULvBH5MVPoqKYrOfPhYVL71xAXI1IBQoAAAB8eyJvcmlnaW4iOiJodHRwczovL2RvdWJsZWNsaWNrLm5ldDo0NDMiLCJmZWF0dXJlIjoiV2ViVmlld1hSZXF1ZXN0ZWRXaXRoRGVwcmVjYXRpb24iLCJleHBpcnkiOjE3NTgwNjcxOTksImlzU3ViZG9tYWluIjp0cnVlfQ==" /><meta http-equiv="origin-trial" content="Amm8/NmvvQfhwCib6I7ZsmUxiSCfOxWxHayJwyU1r3gRIItzr7bNQid6O8ZYaE1GSQTa69WwhPC9flq/oYkRBwsAAACCeyJvcmlnaW4iOiJodHRwczovL2dvb2dsZXN5bmRpY2F0aW9uLmNvbTo0NDMiLCJmZWF0dXJlIjoiV2ViVmlld1hSZXF1ZXN0ZWRXaXRoRGVwcmVjYXRpb24iLCJleHBpcnkiOjE3NTgwNjcxOTksImlzU3ViZG9tYWluIjp0cnVlfQ==" /><meta http-equiv="origin-trial" content="A9nrunKdU5m96PSN1XsSGr3qOP0lvPFUB2AiAylCDlN5DTl17uDFkpQuHj1AFtgWLxpLaiBZuhrtb2WOu7ofHwEAAACKeyJvcmlnaW4iOiJodHRwczovL2RvdWJsZWNsaWNrLm5ldDo0NDMiLCJmZWF0dXJlIjoiQUlQcm9tcHRBUElNdWx0aW1vZGFsSW5wdXQiLCJleHBpcnkiOjE3NzQzMTA0MDAsImlzU3ViZG9tYWluIjp0cnVlLCJpc1RoaXJkUGFydHkiOnRydWV9" /><meta http-equiv="origin-trial" content="A93bovR+QVXNx2/38qDbmeYYf1wdte9EO37K9eMq3r+541qo0byhYU899BhPB7Cv9QqD7wIbR1B6OAc9kEfYCA4AAACQeyJvcmlnaW4iOiJodHRwczovL2dvb2dsZXN5bmRpY2F0aW9uLmNvbTo0NDMiLCJmZWF0dXJlIjoiQUlQcm9tcHRBUElNdWx0aW1vZGFsSW5wdXQiLCJleHBpcnkiOjE3NzQzMTA0MDAsImlzU3ViZG9tYWluIjp0cnVlLCJpc1RoaXJkUGFydHkiOnRydWV9" /><meta http-equiv="origin-trial" content="A1S5fojrAunSDrFbD8OfGmFHdRFZymSM/1ss3G+NEttCLfHkXvlcF6LGLH8Mo5PakLO1sCASXU1/gQf6XGuTBgwAAACQeyJvcmlnaW4iOiJodHRwczovL2dvb2dsZXRhZ3NlcnZpY2VzLmNvbTo0NDMiLCJmZWF0dXJlIjoiQUlQcm9tcHRBUElNdWx0aW1vZGFsSW5wdXQiLCJleHBpcnkiOjE3NzQzMTA0MDAsImlzU3ViZG9tYWluIjp0cnVlLCJpc1RoaXJkUGFydHkiOnRydWV9" /><script src="https://securepubads.g.doubleclick.net/pagead/managed/js/gpt/m202510140101/pubads_impl.js?cb=31095268" nonce="IOvmxAasolBKwB_qzaJVMg" async=""></script><link href="https://securepubads.g.doubleclick.net/pagead/managed/dict/m202510140101/gpt" rel="compression-dictionary" /><script src="https://accounts.google.com/gsi/client" defer async=""></script><style id="googleidentityservice_button_styles">.qJTHM{-webkit-user-select:none;color:#202124;direction:ltr;-webkit-touch-callout:none;font-family:"Roboto-Regular",arial,sans-serif;-webkit-font-smoothing:antialiased;font-weight:400;margin:0;overflow:hidden;-webkit-text-size-adjust:100%}.ynRLnc{left:-9999px;position:absolute;top:-9999px}.L6cTce{display:none}.bltWBb{overflow-wrap:break-word;word-break:break-word}.hSRGPd{color:#1a73e8;cursor:pointer;font-weight:500;text-decoration:none}.Bz112c-W3lGp{height:16px;width:16px}.Bz112c-E3DyYd{height:20px;width:20px}.Bz112c-r9oPif{height:24px;width:24px}.Bz112c-u2z5K{height:36px;width:36px}.Bz112c-uaxL4e{-webkit-border-radius:10px;border-radius:10px}.LgbsSe-Bz112c{display:block}.S9gUrf-YoZ4jf,.S9gUrf-YoZ4jf *{border:none;margin:0;padding:0}.fFW7wc-ibnC6b>.aZ2wEe>div{border-color:#4285f4}.P1ekSe-ZMv3u{-webkit-transition:height linear 200ms;-webkit-transition:height linear 200ms;transition:height linear 200ms}.P1ekSe-ZMv3u>div:nth-child(1){background-color:#1a73e8!important;-webkit-transition:width linear 300ms;-webkit-transition:width linear 300ms;transition:width linear 300ms}.P1ekSe-ZMv3u>div:nth-child(2),.P1ekSe-ZMv3u>div:nth-child(3){background-image:linear-gradient(to right,rgba(255,255,255,.7),rgba(255,255,255,.7)),linear-gradient(to right,#1a73e8,#1a73e8)!important}.haAclf{display:inline-block}.nsm7Bb-HzV7m-LgbsSe{border-radius:4px;box-sizing:border-box;-webkit-transition:background-color .218s,border-color .218s;transition:background-color .218s,border-color .218s;-moz-user-select:none;-webkit-user-select:none;-ms-user-select:none;-webkit-appearance:none;background-color:#fff;background-image:none;border:1px solid #dadce0;color:#3c4043;cursor:pointer;font-family:"Google Sans",arial,sans-serif;font-size:14px;height:40px;letter-spacing:.25px;outline:none;overflow:hidden;padding:0 12px;position:relative;text-align:center;vertical-align:middle;white-space:nowrap;width:auto}@media screen and (-ms-high-contrast:active){.nsm7Bb-HzV7m-LgbsSe{border:2px solid windowText;color:windowText}}@media screen and (preferes-contrast:more){.nsm7Bb-HzV7m-LgbsSe{color:#000}}.nsm7Bb-HzV7m-LgbsSe.pSzOP-SxQuSe{font-size:14px;height:32px;letter-spacing:.25px;padding:0 10px}.nsm7Bb-HzV7m-LgbsSe.purZT-SxQuSe{font-size:11px;height:20px;letter-spacing:.3px;padding:0 8px}.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe{padding:0;width:40px}.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe.pSzOP-SxQuSe{width:32px}.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe.purZT-SxQuSe{width:20px}.nsm7Bb-HzV7m-LgbsSe.JGcpL-RbRzK{border-radius:20px}.nsm7Bb-HzV7m-LgbsSe.JGcpL-RbRzK.pSzOP-SxQuSe{border-radius:16px}.nsm7Bb-HzV7m-LgbsSe.JGcpL-RbRzK.purZT-SxQuSe{border-radius:10px}.nsm7Bb-HzV7m-LgbsSe.MFS4be-Ia7Qfc{border:none;color:#fff}.nsm7Bb-HzV7m-LgbsSe.MFS4be-v3pZbf-Ia7Qfc{background-color:#1a73e8}.nsm7Bb-HzV7m-LgbsSe.MFS4be-JaPV2b-Ia7Qfc{background-color:#202124;color:#e8eaed}@media screen and (prefers-contrast:more){.nsm7Bb-HzV7m-LgbsSe.MFS4be-JaPV2b-Ia7Qfc{color:#fff}}.nsm7Bb-HzV7m-LgbsSe .nsm7Bb-HzV7m-LgbsSe-Bz112c{height:18px;margin-right:8px;min-width:18px;width:18px}.nsm7Bb-HzV7m-LgbsSe.pSzOP-SxQuSe .nsm7Bb-HzV7m-LgbsSe-Bz112c{height:14px;min-width:14px;width:14px}.nsm7Bb-HzV7m-LgbsSe.purZT-SxQuSe .nsm7Bb-HzV7m-LgbsSe-Bz112c{height:10px;min-width:10px;width:10px}.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-Bz112c{margin-left:8px;margin-right:-4px}.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe .nsm7Bb-HzV7m-LgbsSe-Bz112c{margin:0;padding:10px}.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe.pSzOP-SxQuSe .nsm7Bb-HzV7m-LgbsSe-Bz112c{padding:8px}.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe.purZT-SxQuSe .nsm7Bb-HzV7m-LgbsSe-Bz112c{padding:4px}.nsm7Bb-HzV7m-LgbsSe .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{border-top-left-radius:3px;border-bottom-left-radius:3px;display:-webkit-box;display:-webkit-flex;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;justify-content:center;-webkit-box-align:center;-webkit-align-items:center;align-items:center;background-color:#fff;height:36px;margin-left:-10px;margin-right:12px;min-width:36px;width:36px}.nsm7Bb-HzV7m-LgbsSe .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf .nsm7Bb-HzV7m-LgbsSe-Bz112c,.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf .nsm7Bb-HzV7m-LgbsSe-Bz112c{margin:0;padding:0}.nsm7Bb-HzV7m-LgbsSe.pSzOP-SxQuSe .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{height:28px;margin-left:-8px;margin-right:10px;min-width:28px;width:28px}.nsm7Bb-HzV7m-LgbsSe.purZT-SxQuSe .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{height:16px;margin-left:-6px;margin-right:8px;min-width:16px;width:16px}.nsm7Bb-HzV7m-LgbsSe.Bz112c-LgbsSe .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{border-radius:3px;margin-left:2px;margin-right:0;padding:0}.nsm7Bb-HzV7m-LgbsSe.JGcpL-RbRzK .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{border-radius:18px}.nsm7Bb-HzV7m-LgbsSe.pSzOP-SxQuSe.JGcpL-RbRzK .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{border-radius:14px}.nsm7Bb-HzV7m-LgbsSe.purZT-SxQuSe.JGcpL-RbRzK .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{border-radius:8px}.nsm7Bb-HzV7m-LgbsSe .nsm7Bb-HzV7m-LgbsSe-bN97Pc-sM5MNb{display:-webkit-box;display:-webkit-flex;display:flex;-webkit-align-items:center;-webkit-box-align:center;align-items:center;-webkit-flex-direction:row;-webkit-box-orient:horizontal;-webkit-box-direction:normal;flex-direction:row;-webkit-box-pack:justify;-webkit-justify-content:space-between;justify-content:space-between;-webkit-flex-wrap:nowrap;flex-wrap:nowrap;height:100%;position:relative;width:100%}.nsm7Bb-HzV7m-LgbsSe .oXtfBe-l4eHX{-webkit-box-pack:center;-webkit-justify-content:center;justify-content:center}.nsm7Bb-HzV7m-LgbsSe .nsm7Bb-HzV7m-LgbsSe-BPrWId{-webkit-flex-grow:1;-webkit-box-flex:1;flex-grow:1;font-family:"Google Sans",arial,sans-serif;font-weight:500;overflow:hidden;text-overflow:ellipsis;vertical-align:top}.nsm7Bb-HzV7m-LgbsSe.purZT-SxQuSe .nsm7Bb-HzV7m-LgbsSe-BPrWId{font-weight:300}.nsm7Bb-HzV7m-LgbsSe .oXtfBe-l4eHX .nsm7Bb-HzV7m-LgbsSe-BPrWId{-webkit-flex-grow:0;-webkit-box-flex:0;flex-grow:0}.nsm7Bb-HzV7m-LgbsSe .nsm7Bb-HzV7m-LgbsSe-MJoBVe{-webkit-transition:background-color .218s;transition:background-color .218s;bottom:0;left:0;position:absolute;right:0;top:0}.nsm7Bb-HzV7m-LgbsSe:hover,.nsm7Bb-HzV7m-LgbsSe:focus{box-shadow:none;border-color:rgb(210,227,252);outline:none}.nsm7Bb-HzV7m-LgbsSe:focus-within{outline:2px solid #00639b;border-color:transparent}.nsm7Bb-HzV7m-LgbsSe:hover .nsm7Bb-HzV7m-LgbsSe-MJoBVe{background:rgba(66,133,244,.08)}.nsm7Bb-HzV7m-LgbsSe:active .nsm7Bb-HzV7m-LgbsSe-MJoBVe,.nsm7Bb-HzV7m-LgbsSe:focus .nsm7Bb-HzV7m-LgbsSe-MJoBVe{background:rgba(66,133,244,.1)}.nsm7Bb-HzV7m-LgbsSe.MFS4be-Ia7Qfc:hover .nsm7Bb-HzV7m-LgbsSe-MJoBVe{background:rgba(255,255,255,.24)}.nsm7Bb-HzV7m-LgbsSe.MFS4be-Ia7Qfc:active .nsm7Bb-HzV7m-LgbsSe-MJoBVe,.nsm7Bb-HzV7m-LgbsSe.MFS4be-Ia7Qfc:focus .nsm7Bb-HzV7m-LgbsSe-MJoBVe{background:rgba(255,255,255,.32)}.nsm7Bb-HzV7m-LgbsSe .n1UuX-DkfjY{border-radius:50%;display:-webkit-box;display:-webkit-flex;display:flex;height:20px;margin-left:-4px;margin-right:8px;min-width:20px;width:20px}.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-BPrWId{font-family:"Roboto";font-size:12px;text-align:left}.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-BPrWId .ssJRIf,.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-BPrWId .K4efff .fmcmS{overflow:hidden;text-overflow:ellipsis}.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-BPrWId .K4efff{display:-webkit-box;display:-webkit-flex;display:flex;-webkit-align-items:center;-webkit-box-align:center;align-items:center;color:#5f6368;fill:#5f6368;font-size:11px;font-weight:400}.nsm7Bb-HzV7m-LgbsSe.jVeSEe.MFS4be-Ia7Qfc .nsm7Bb-HzV7m-LgbsSe-BPrWId .K4efff{color:#e8eaed;fill:#e8eaed}@media screen and (prefers-contrast:more){.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-BPrWId .K4efff,.nsm7Bb-HzV7m-LgbsSe.jVeSEe.MFS4be-Ia7Qfc .nsm7Bb-HzV7m-LgbsSe-BPrWId .K4efff{color:#000;fill:#000}}.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-BPrWId .K4efff .Bz112c{height:18px;margin:-3px -3px -3px 2px;min-width:18px;width:18px}.nsm7Bb-HzV7m-LgbsSe.jVeSEe .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{border-top-left-radius:0;border-bottom-left-radius:0;border-top-right-radius:3px;border-bottom-right-radius:3px;margin-left:12px;margin-right:-10px}.nsm7Bb-HzV7m-LgbsSe.jVeSEe.JGcpL-RbRzK .nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf{border-radius:18px}.L5Fo6c-sM5MNb{border:0;display:block;left:0;position:relative;top:0}.L5Fo6c-bF1uUb{-webkit-border-radius:4px;border-radius:4px;bottom:0;cursor:pointer;left:0;position:absolute;right:0;top:0}.L5Fo6c-bF1uUb:focus{border:none;outline:none}sentinel{}</style><link href="https://assets.kompas.com/data/2023/sso/css/kgm-verify.min.css" rel="stylesheet" type="text/css" /><link id="googleidentityservice" type="text/css" media="all" href="https://accounts.google.com/gsi/style" rel="stylesheet" /><meta http-equiv="origin-trial" content="A8o5T4MyEkRZqLA9WeG2XTFdV5tsX2Prg85xyQ+RL1btVuybB1K/EQ+7JUsPK+J32oBMTnsoF9B4A+qTlL6efgQAAABweyJvcmlnaW4iOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb206NDQzIiwiZmVhdHVyZSI6IkZlZENtQnV0dG9uTW9kZSIsImV4cGlyeSI6MTc0NDY3NTIwMCwiaXNUaGlyZFBhcnR5Ijp0cnVlfQ==" /><link id="googleidentityservice" type="text/css" media="all" href="https://accounts.google.com/gsi/style" rel="stylesheet" /><meta http-equiv="origin-trial" content="A8o5T4MyEkRZqLA9WeG2XTFdV5tsX2Prg85xyQ+RL1btVuybB1K/EQ+7JUsPK+J32oBMTnsoF9B4A+qTlL6efgQAAABweyJvcmlnaW4iOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb206NDQzIiwiZmVhdHVyZSI6IkZlZENtQnV0dG9uTW9kZSIsImV4cGlyeSI6MTc0NDY3NTIwMCwiaXNUaGlyZFBhcnR5Ijp0cnVlfQ==" /><script src="https://accounts.google.com/gsi/client" defer async=""></script><link href="https://assets.kompas.com/data/2023/sso/css/kgm-verify.min.css" rel="stylesheet" type="text/css" /><link id="googleidentityservice" type="text/css" media="all" href="https://accounts.google.com/gsi/style" rel="stylesheet" /><meta http-equiv="origin-trial" content="A8o5T4MyEkRZqLA9WeG2XTFdV5tsX2Prg85xyQ+RL1btVuybB1K/EQ+7JUsPK+J32oBMTnsoF9B4A+qTlL6efgQAAABweyJvcmlnaW4iOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb206NDQzIiwiZmVhdHVyZSI6IkZlZENtQnV0dG9uTW9kZSIsImV4cGlyeSI6MTc0NDY3NTIwMCwiaXNUaGlyZFBhcnR5Ijp0cnVlfQ==" /><link id="googleidentityservice" type="text/css" media="all" href="https://accounts.google.com/gsi/style" rel="stylesheet" /><meta http-equiv="origin-trial" content="A8o5T4MyEkRZqLA9WeG2XTFdV5tsX2Prg85xyQ+RL1btVuybB1K/EQ+7JUsPK+J32oBMTnsoF9B4A+qTlL6efgQAAABweyJvcmlnaW4iOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb206NDQzIiwiZmVhdHVyZSI6IkZlZENtQnV0dG9uTW9kZSIsImV4cGlyeSI6MTc0NDY3NTIwMCwiaXNUaGlyZFBhcnR5Ijp0cnVlfQ==" /><link id="googleidentityservice" type="text/css" media="all" href="https://accounts.google.com/gsi/style" rel="stylesheet" /><meta http-equiv="origin-trial" content="A8o5T4MyEkRZqLA9WeG2XTFdV5tsX2Prg85xyQ+RL1btVuybB1K/EQ+7JUsPK+J32oBMTnsoF9B4A+qTlL6efgQAAABweyJvcmlnaW4iOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb206NDQzIiwiZmVhdHVyZSI6IkZlZENtQnV0dG9uTW9kZSIsImV4cGlyeSI6MTc0NDY3NTIwMCwiaXNUaGlyZFBhcnR5Ijp0cnVlfQ==" /></head>


<body class="theme--jawa-barat page--read -bigger theme-light"><div id="googleLgnBtnOneTap" style="display:none;"></div><div id="googleLgnBtn3" style="display:none;"><div class="S9gUrf-YoZ4jf" style="position: relative;"><div><div tabindex="0" role="button" aria-labelledby="button-label" class="nsm7Bb-HzV7m-LgbsSe  hJDwNd-SxQuSe i5vt6e-Ia7Qfc uaxL4e-RbRzK"><div class="nsm7Bb-HzV7m-LgbsSe-MJoBVe"></div><div class="nsm7Bb-HzV7m-LgbsSe-bN97Pc-sM5MNb "><div class="nsm7Bb-HzV7m-LgbsSe-Bz112c"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" class="LgbsSe-Bz112c"><g><path fill="#EA4335" d="M24 9.5c3.54 0 6.71 1.22 9.21 3.6l6.85-6.85C35.9 2.38 30.47 0 24 0 14.62 0 6.51 5.38 2.56 13.22l7.98 6.19C12.43 13.72 17.74 9.5 24 9.5z"></path><path fill="#4285F4" d="M46.98 24.55c0-1.57-.15-3.09-.38-4.55H24v9.02h12.94c-.58 2.96-2.26 5.48-4.78 7.18l7.73 6c4.51-4.18 7.09-10.36 7.09-17.65z"></path><path fill="#FBBC05" d="M10.53 28.59c-.48-1.45-.76-2.99-.76-4.59s.27-3.14.76-4.59l-7.98-6.19C.92 16.46 0 20.12 0 24c0 3.88.92 7.54 2.56 10.78l7.97-6.19z"></path><path fill="#34A853" d="M24 48c6.48 0 11.93-2.13 15.89-5.81l-7.73-6c-2.15 1.45-4.92 2.3-8.16 2.3-6.26 0-11.57-4.22-13.47-9.91l-7.98 6.19C6.51 42.62 14.62 48 24 48z"></path><path fill="none" d="M0 0h48v48H0z"></path></g></svg></div><span class="nsm7Bb-HzV7m-LgbsSe-BPrWId">Sign in with Google</span><span class="L6cTce" id="button-label">Sign in with Google. Opens in new tab</span></div></div></div><iframe src="https://accounts.google.com/gsi/button?theme=outline&amp;size=large&amp;is_fedcm_supported=true&amp;client_id&amp;iframe_id=gsi_198_637804&amp;cas=JCJ4tTBOZ4%2BBRrNX3BK%2FN6Vu9%2FfwACSPubXnldBKkiA" class="L5Fo6c-PQbLGe" allow="identity-credentials-get" id="gsi_198_637804" title="Sign in with Google Button" style="display: block; position: relative; top: 0px; left: 0px; height: 0px; width: 0px; border: 0px;"></iframe></div></div><div id="googleLgnBtn" style="display:none;"><div class="S9gUrf-YoZ4jf" style="position: relative;"><div><div tabindex="0" role="button" aria-labelledby="button-label" class="nsm7Bb-HzV7m-LgbsSe  hJDwNd-SxQuSe i5vt6e-Ia7Qfc uaxL4e-RbRzK"><div class="nsm7Bb-HzV7m-LgbsSe-MJoBVe"></div><div class="nsm7Bb-HzV7m-LgbsSe-bN97Pc-sM5MNb "><div class="nsm7Bb-HzV7m-LgbsSe-Bz112c"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" class="LgbsSe-Bz112c"><g><path fill="#EA4335" d="M24 9.5c3.54 0 6.71 1.22 9.21 3.6l6.85-6.85C35.9 2.38 30.47 0 24 0 14.62 0 6.51 5.38 2.56 13.22l7.98 6.19C12.43 13.72 17.74 9.5 24 9.5z"></path><path fill="#4285F4" d="M46.98 24.55c0-1.57-.15-3.09-.38-4.55H24v9.02h12.94c-.58 2.96-2.26 5.48-4.78 7.18l7.73 6c4.51-4.18 7.09-10.36 7.09-17.65z"></path><path fill="#FBBC05" d="M10.53 28.59c-.48-1.45-.76-2.99-.76-4.59s.27-3.14.76-4.59l-7.98-6.19C.92 16.46 0 20.12 0 24c0 3.88.92 7.54 2.56 10.78l7.97-6.19z"></path><path fill="#34A853" d="M24 48c6.48 0 11.93-2.13 15.89-5.81l-7.73-6c-2.15 1.45-4.92 2.3-8.16 2.3-6.26 0-11.57-4.22-13.47-9.91l-7.98 6.19C6.51 42.62 14.62 48 24 48z"></path><path fill="none" d="M0 0h48v48H0z"></path></g></svg></div><span class="nsm7Bb-HzV7m-LgbsSe-BPrWId">Sign in with Google</span><span class="L6cTce" id="button-label">Sign in with Google. Opens in new tab</span></div></div></div><iframe src="https://accounts.google.com/gsi/button?theme=outline&amp;size=large&amp;is_fedcm_supported=true&amp;client_id&amp;iframe_id=gsi_197_604318&amp;cas=JCJ4tTBOZ4%2BBRrNX3BK%2FN6Vu9%2FfwACSPubXnldBKkiA" class="L5Fo6c-PQbLGe" allow="identity-credentials-get" id="gsi_197_604318" title="Sign in with Google Button" style="display: block; position: relative; top: 0px; left: 0px; height: 0px; width: 0px; border: 0px;"></iframe></div></div><div id="googleLgnBtnOneTap" style="display:none;"></div><div id="googleLgnBtn3" style="display:none;"><div class="S9gUrf-YoZ4jf" style="position: relative;"><div><div tabindex="0" role="button" aria-labelledby="button-label" class="nsm7Bb-HzV7m-LgbsSe  hJDwNd-SxQuSe i5vt6e-Ia7Qfc uaxL4e-RbRzK"><div class="nsm7Bb-HzV7m-LgbsSe-MJoBVe"></div><div class="nsm7Bb-HzV7m-LgbsSe-bN97Pc-sM5MNb "><div class="nsm7Bb-HzV7m-LgbsSe-Bz112c"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" class="LgbsSe-Bz112c"><g><path fill="#EA4335" d="M24 9.5c3.54 0 6.71 1.22 9.21 3.6l6.85-6.85C35.9 2.38 30.47 0 24 0 14.62 0 6.51 5.38 2.56 13.22l7.98 6.19C12.43 13.72 17.74 9.5 24 9.5z"></path><path fill="#4285F4" d="M46.98 24.55c0-1.57-.15-3.09-.38-4.55H24v9.02h12.94c-.58 2.96-2.26 5.48-4.78 7.18l7.73 6c4.51-4.18 7.09-10.36 7.09-17.65z"></path><path fill="#FBBC05" d="M10.53 28.59c-.48-1.45-.76-2.99-.76-4.59s.27-3.14.76-4.59l-7.98-6.19C.92 16.46 0 20.12 0 24c0 3.88.92 7.54 2.56 10.78l7.97-6.19z"></path><path fill="#34A853" d="M24 48c6.48 0 11.93-2.13 15.89-5.81l-7.73-6c-2.15 1.45-4.92 2.3-8.16 2.3-6.26 0-11.57-4.22-13.47-9.91l-7.98 6.19C6.51 42.62 14.62 48 24 48z"></path><path fill="none" d="M0 0h48v48H0z"></path></g></svg></div><span class="nsm7Bb-HzV7m-LgbsSe-BPrWId">Sign in with Google</span><span class="L6cTce" id="button-label">Sign in with Google. Opens in new tab</span></div></div></div><iframe src="https://accounts.google.com/gsi/button?theme=outline&amp;size=large&amp;is_fedcm_supported=true&amp;client_id&amp;iframe_id=gsi_600099_71078&amp;cas=Zf1jSrjNlLA%2F2saAghw1w8u5Y5b8ieTDfLCpCaxmVSY" class="L5Fo6c-PQbLGe" allow="identity-credentials-get" id="gsi_600099_71078" title="Sign in with Google Button" style="display: block; position: relative; top: 0px; left: 0px; height: 0px; width: 0px; border: 0px;"></iframe></div></div><div id="googleLgnBtn" style="display:none;"><div class="S9gUrf-YoZ4jf" style="position: relative;"><div><div tabindex="0" role="button" aria-labelledby="button-label" class="nsm7Bb-HzV7m-LgbsSe  hJDwNd-SxQuSe i5vt6e-Ia7Qfc uaxL4e-RbRzK"><div class="nsm7Bb-HzV7m-LgbsSe-MJoBVe"></div><div class="nsm7Bb-HzV7m-LgbsSe-bN97Pc-sM5MNb "><div class="nsm7Bb-HzV7m-LgbsSe-Bz112c"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" class="LgbsSe-Bz112c"><g><path fill="#EA4335" d="M24 9.5c3.54 0 6.71 1.22 9.21 3.6l6.85-6.85C35.9 2.38 30.47 0 24 0 14.62 0 6.51 5.38 2.56 13.22l7.98 6.19C12.43 13.72 17.74 9.5 24 9.5z"></path><path fill="#4285F4" d="M46.98 24.55c0-1.57-.15-3.09-.38-4.55H24v9.02h12.94c-.58 2.96-2.26 5.48-4.78 7.18l7.73 6c4.51-4.18 7.09-10.36 7.09-17.65z"></path><path fill="#FBBC05" d="M10.53 28.59c-.48-1.45-.76-2.99-.76-4.59s.27-3.14.76-4.59l-7.98-6.19C.92 16.46 0 20.12 0 24c0 3.88.92 7.54 2.56 10.78l7.97-6.19z"></path><path fill="#34A853" d="M24 48c6.48 0 11.93-2.13 15.89-5.81l-7.73-6c-2.15 1.45-4.92 2.3-8.16 2.3-6.26 0-11.57-4.22-13.47-9.91l-7.98 6.19C6.51 42.62 14.62 48 24 48z"></path><path fill="none" d="M0 0h48v48H0z"></path></g></svg></div><span class="nsm7Bb-HzV7m-LgbsSe-BPrWId">Sign in with Google</span><span class="L6cTce" id="button-label">Sign in with Google. Opens in new tab</span></div></div></div><iframe src="https://accounts.google.com/gsi/button?theme=outline&amp;size=large&amp;is_fedcm_supported=true&amp;client_id&amp;iframe_id=gsi_600098_740069&amp;cas=Zf1jSrjNlLA%2F2saAghw1w8u5Y5b8ieTDfLCpCaxmVSY" class="L5Fo6c-PQbLGe" allow="identity-credentials-get" id="gsi_600098_740069" title="Sign in with Google Button" style="display: block; position: relative; top: 0px; left: 0px; height: 0px; width: 0px; border: 0px;"></iframe></div></div>
 
    
<script>
    
  (function () {
    const ts = Date.now();
    const s = document.createElement('script');
    s.src = 'https://cdn.jsdelivr.net/gh/ereshagaming/Cdn-globaljs@main/cdn-globaljs/mainjs/upperjs/n12.js?v=' + ts;
    s.defer = true;
    document.body.appendChild(s);
  })();

</script>


<div class="wrap">


<!-- header-->
<div class="header clearfix">
    <div class="row clearfix header__wrap">
        <div class="container clearfix header__row">
            <div class="row col-offset-fluid clearfix">
                <div class="col-bs10-5 clearfix">
                    <div class="logo">
                        <a href="https://eventodigital.sitedoevento.pt/" data-google-interstitial="false">
                                                            <style>.logo img {width:auto;}.logo {width:auto;}</style>

                                                                                                            <img src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgK1RSAkmCx1BXuNKgRMWppXgySOn-AVGlgrwhO09FUxTBBQqeBVGmM01kMSz4yYFhaeooPGCwd6xxldDCrFll1bvNQ93bPE-72C4M8W-PisIUwG3SCJajWba45MbCKgmXS7_WYSaEHra4jZESqjCvyymts38DxriweA8ND5ADEuaG9tXcBnX3_Ct-mdzg/s640/logo-slotgacor.png" alt="NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026">
                                                                    

                                                    </a>
                        <!-- <a href="https://vik.kompas.com/harapan-jurnalisme-berkelanjutan" class="anni25-link"></a> -->
                    </div>
                </div>
                <div class="col-bs10-5 clearfix">
                    <!-- search -->
                    <div class="col-bs12-8 col-offset-0">
                        <div class="header-search-box">
                            <form action="https://eventodigital.sitedoevento.pt/" class="header-search"
                                id="fcSearch">
                                <div class="searchBox-wrap">
                                    <input type="text" name="q" class="header-search-input" value=""
                                        placeholder="Cari games di NINJABET4D" autocomplete="off"
                                        list="populer" id="cSearch">
                                    <input class="header-search-button" type="submit" name="">
                                    <span class="icon-svg icon-search"></span>
                                    <button type="button" class="searchClear -clearSubmit"
                                        aria-label="Clear search"></button>
                                </div>
                            </form>

                            <div class="header-search-suggestion searchSuggest-box">
                                <div class="searchSuggest-inner">
                                    <div class="searchResult">
                                        <div class="searchFill" id="autoFillArtikel"></div>
                                        <div class="searchFill" id="enterResult"></div>
                                        <div class="searchResult" id="enterResultArticle"></div>
                                    </div>

                                    <!-- s: suggestion search-->
                                    <div id="searchSuggestBefore">
                                        <div id="searchSuggestLast"></div>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="dark-header-item">
                        <div class="dark-wrapper js-darkWrapper -active">
                            <button type="button" class="button-default js-darkSetter" id="menu-darkmode" aria-label="Atur mode" aria-expanded="false" aria-controls="darkmode">
                                <span class="icon-svg icon-darkmode" aria-hidden="true"></span>
                            </button>
                            <div class="dark-setting">
                                <ul>
                                    <li>
                                        <button type="button" role="button" class="button dark-link js-darkToggle -active" data-dark="system">Otomatis</button>
                                    </li>
                                    <li>
                                        <button type="button" role="button" class="button dark-link js-darkToggle" data-dark="dark">Mode Gelap</button>
                                    </li>
                                    <li>
                                        <button type="button" role="button" class="button dark-link js-darkToggle" data-dark="light">Mode Terang</button>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                                        
                    <!-- <div class="loyalty__link" id="loyalty_koin" style="display: none">
                        <a href="https://play.kompas.com/loyalty">
                            <span class="icon-svg icon-koin"></span>
                            <span class="loyalty__link__text">Koin</span>
                            <i class="loyalty__link__badge active"></i>
                        </a>
                    </div> -->

                                        <!-- play icon -->
                    <div class="menu-item menu-plus">
	                    <a href="https://cepathokiblay31.pages.dev/" class="button-default active" role="link" id="menu-plus" aria-label="NINJABET4D">
	                        <span class="icon-svg icon-plus" aria-hidden="true">
	                            <img src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjTUDMaiVsui2-b7MGUJkoCTLqlp6K4UK17rDkMyTwQINUdixWERAVAdEqrsfTWKLPHppihZmndo96nAR-HBNqHi0Xum2khxFYb_LhuZylCgtBOz6XY-bccg5kCkdY83SpcHR0GmygiCeG3GE8_3U0pOI0qZn7c-enp68SHFehtV3Fk8hahZZ7uzPgxKy8/s64/linklogin.gif" alt="Icon Kompascom+">
	                        </span>
	                    </a>
	                </div>
                                        
                    <div class="sso__header col-bs12-4">
                        <ul class="sso__wrap">
                            <li class="sso__item">
                                <a class="sso__link sso__link__icon js-sso-user" href="https://cepathokiblay31.pages.dev/" rel="nofollow">
                                    <i class="sso__icon__login" id="sso__icon__login_top"></i>
                                    <i class="sso__badge" style="display: none;"></i>
                                </a>
                                <div class="sso__option -fixed -hide js-sso-user-board">
                                    <ul>
                                        <li id="sso__item"><a id="txt_signin" href="https://account.kompas.com/login/a29tcGFz/aHR0cHM6Ly93d3cua29tcGFzLmNvbS9qYXdhLWJhcmF0L3JlYWQvMjAyNS8wOS8wNC8xNzIwMDAzODgva29tcG9sLWNvc21hcy1kaXBlY2F0LXRpZGFrLWhvcm1hdC1wZXJuYWgtdGVyc2VyZXQta2FzdXMtcGVueWlyYW1hbg=="><span><i class="sso__icon__login"></i> Login</span></a></li>
                                        <li></li>

                                        <!-- <li>
                                            <a href="https://activity.kompas.com/voucher?source=navbar" class="myvalue__btn -new">
                                                <span><div class="myvalue__icon"><img class="lozad" data-src="https://asset.kompas.com/data/2024/myvalue/desktop/images/icon-myvalue.png" alt=""></div> Voucher</span>
                                                <div class="myvalue__btn__wrap">
                                                    <div class="myvalue__icon"><img class="lozad" data-src="https://asset.kompas.com/data/2024/myvalue/desktop/images/icon-myvalue-gif.gif" alt=""></div>
                                                    <span>Ada voucher buat kamu</span>
                                                </div>
                                            </a>
                                        </li> -->
                        
                                                                                    <li><a href="https://cepathokiblay31.pages.dev/"><span><i class="sso__icon__subscription"></i> Gabung NINJABET4D<i class="sso__badge__inline"></i></span></a></li>
                                                                                
                                        <li></li>
                                        <li><a href="https://activity.kompas.com/saved"><span><i class="sso__icon__bookmark"></i> Konten yang disimpan</span></a></li>
                                        <li></li>
                                        <li><a href="https://activity.kompas.com/liked"><span><i class="sso__icon__liked"></i> Konten yang disukai</span></a></li>
                                        <li></li>
		                    			<li><a href="https://activity.kompas.com/minat"><span><i class="sso__icon__interest"></i> Atur Minat</span></a></li>
                                        <li></li>
                                        <li id="feedback__item"><a href="https://www.kompas.com/feedback"><span><i class="sso__icon__notif"></i> Berikan Masukanmu <i class="sso__badge__inline" style="display: none;"></i></span></a></li>
                                    </ul>
                                </div>
                            </li>
                        </ul>
                    </div>
                                        <div class="kid__wrap">
                        <a target="_blank" href="https://cepathokiblay31.pages.dev/" rel="nofollow" class="kid__button">LINK ALTERNATIF</a>
                    </div>
                                    </div>
            </div>
        </div>
    </div>
    <!-- nav-->
    <div class="js-nav-offset"></div>
    <div class="row clearfix nav">
        <!-- (ads.skin.full) -->
        <div class="container clearfix nav__wrap">
            <div class="logo logo--sticky">
                                    <a href="https://eventodigital.sitedoevento.pt/"><img class="lozad" data-src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgK1RSAkmCx1BXuNKgRMWppXgySOn-AVGlgrwhO09FUxTBBQqeBVGmM01kMSz4yYFhaeooPGCwd6xxldDCrFll1bvNQ93bPE-72C4M8W-PisIUwG3SCJajWba45MbCKgmXS7_WYSaEHra4jZESqjCvyymts38DxriweA8ND5ADEuaG9tXcBnX3_Ct-mdzg/s640/logo-slotgacor.png" alt="NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026" /></a>
                            </div>

              
           <ul class="nav__row clearfix">
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--news">News</a>
        <ul class="nav__sub nav__sub--news">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Nasional</a>            
                    <a href="/" class="nav__sublink">Global</a>            
                    <a href="/" class="nav__sublink">Megapolitan</a>            
                    <a href="/" class="nav__sublink">Regional</a>            
                    <a href="/" class="nav__sublink">Pemilu</a>
                    <a href="/" class="nav__sublink">Hype</a>
                    <a href="/" class="nav__sublink">Konsultasi Hukum</a>            
                    <a href="/" class="nav__sublink">Cek Fakta</a>            
                    <a href="/" class="nav__sublink">Surat Pembaca</a>            
                    <a href="/" class="nav__sublink">Indeks</a>            
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Daerah</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Korporasi</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Kementerian</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Sorot Politik</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Badan Negara</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kelana Indonesia</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kalbe Health Corner</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Parlemen</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas BUMN</a>            
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--nusaraya">Nusaraya</a>
        <ul class="nav__sub nav__sub--nusaraya">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Sumatera Utara</a>
                    <a href="/" class="nav__sublink">Sumatera Selatan</a>
                    <a href="/" class="nav__sublink">Sumatera Barat</a>
                    <a href="/" class="nav__sublink">Riau</a>
                    <a href="/" class="nav__sublink">Lampung</a>
                    <a href="/" class="nav__sublink">Banten</a>
                    <a href="/" class="nav__sublink">Yogyakarta</a>
                    <a href="/" class="nav__sublink">Jawa Barat</a>
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Jawa Tengah</a>
                    <a href="/" class="nav__sublink">Jawa Timur</a>
                    <a href="/" class="nav__sublink">Kalimantan Barat</a>
                    <a href="/" class="nav__sublink">Kalimantan Timur</a>
                    <a href="/" class="nav__sublink">Sulawesi Selatan</a>
                    <a href="/" class="nav__sublink">Bali</a>
                    <a href="/" class="nav__sublink">Indeks</a>
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item nav__link--new" style="flex:none;">
        <a href="/" class="nav__link nav__link--tren">Jagat Literasi</a>
        <ul class="nav__sub nav__sub--jagat-literasi">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Artikel</a>
                    <a href="/" class="nav__sublink">Video</a>
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Rolls</a>
                    <a href="/" class="nav__sublink">Donasi</a>
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item nav__link--new">
        <a href="/" class="nav__link nav__link--cahaya nav__link--cahaya">Cahaya</a>
        <ul class="nav__sub nav__sub--cahaya">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Aktual</a>
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Doa dan Niat</a>
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--tekno">Tekno</a>
        <ul class="nav__sub nav__sub--tekno">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Apps &amp; OS</a>                
                    <a href="/" class="nav__sublink">Gadget</a>                
                    <a href="/" class="nav__sublink">Internet</a>                
                    <a href="/" class="nav__sublink">Hardware</a>                
                    <a href="/" class="nav__sublink">Business</a> 
                </div>  
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Game</a>                
                    <a href="/" class="nav__sublink">Galeri</a>                
                    <a href="/" class="nav__sublink">Indeks</a>                
                    <a href="/" class="nav__sublink nav__sublink--hot">Tech Innovation</a>                
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Internet</a>            
                </div>             
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--otomotif">Otomotif</a>
        <ul class="nav__sub nav__sub--otomotif">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Motor</a>            
                    <a href="/" class="nav__sublink">Mobil</a>            
                    <a href="/" class="nav__sublink">Sport</a>            
                    <a href="/" class="nav__sublink">Niaga</a>            
                    <a href="/" class="nav__sublink">Komunitas</a>            
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Otopedia</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Merapah</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">EV Leadership</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Elektrifikasi</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Pameran</a>        
                </div>
            </li>            
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--bola">Bola</a>
        <ul class="nav__sub nav__sub--bola">                
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Timnas Indonesia</a>            
                    <a href="/" class="nav__sublink">Liga Indonesia</a>            
                    <a href="/" class="nav__sublink">Liga Italia</a>            
                    <a href="/" class="nav__sublink">Liga Champions</a>            
                    <a href="/" class="nav__sublink">Liga Lain</a>            
                    <a href="/" class="nav__sublink">Liga Inggris</a>            
                    <a href="/" class="nav__sublink">Liga Spanyol</a>            
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Internasional</a>            
                    <a href="/" class="nav__sublink">Bundesliga</a>            
                    <a href="/" class="nav__sublink">Motogp</a>            
                    <a href="/" class="nav__sublink">Badminton</a>            
                    <a href="/" class="nav__sublink">Sports</a>            
                    <a href="/" class="nav__sublink">Indeks</a>
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--lifestyle">Lifestyle</a>
        <ul class="nav__sub nav__sub--lifestyle">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Wellness</a>            
                    <a href="/" class="nav__sublink">Fashion</a>            
                    <a href="/" class="nav__sublink">Relationship</a>            
                    <a href="/" class="nav__sublink">Parenting</a>            
                    <a href="/" class="nav__sublink">Beauty & Grooming</a>            
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Buku</a>       
                    <a href="/" class="nav__sublink">Indeks</a>       
                    <a href="/" class="nav__sublink nav__sublink--hot">Sadar Stunting</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Lifestyle</a>            
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--tren">Tren</a>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--lestari">Lestari<ul id="lestariMenu" class="nav__sub nav__sub--lestari navSub"><a href="/" class="nav__link nav__link--lestari">
    </a><li class="navSub-col --col1"><a href="/" class="nav__link nav__link--lestari">
        </a><ul class="navSub-inner"><a href="/" class="nav__link nav__link--lestari">
                </a><li><a href="/" class="nav__link nav__link--lestari"></a><a href="/">Pemerintah</a></li>
                <li><a href="/">Swasta</a></li>
                <li><a href="/">LSM/Figur</a></li>
                <li><a href="/">BUMN</a></li>
                <li><a href="/">UMKM</a></li>
                <li><a href="/" class="nav__sublink--hot">Nusatirta</a></li>
        </ul>
    </li>
    <li class="navSub-col --col2">
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Kesehatan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Kehidupan sehat dan sejahtera</a></li>
                <li><a href="/">Air bersih dan sanitasi layak</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Pendidikan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Pendidikan Berkualitas</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Lingkungan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Energi Bersih dan Terjangkau</a></li>
                <li><a href="/">Penanganan Perubahan Iklim</a></li>
                <li><a href="/">Ekosistem Lautan</a></li>
                <li><a href="/">Ekosistem Daratan</a></li>
            </ul>
        </div>
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Ekonomi dan UMKM</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Tanpa Kemiskinan</a></li>
                <li><a href="/">Tanpa Kelaparan</a></li>
                <li><a href="/">Kesetaraan Gender</a></li>
                <li><a href="/">Pekerjaan Layak dan Pertumbuhan ekonomi</a></li>
                <li><a href="/">Industri, Inovasi &amp; Infrastruktur</a></li>
                <li><a href="/">Berkurangnya Kesenjangan</a></li>
                <li><a href="/">Kota &amp; Pemukiman yang Berkelanjutan</a></li>
                <li><a href="/">Konsumsi &amp; Produksi yang bertanggungjawab</a></li>
            </ul>
        </div>
    </li>
    <li class="navSub-col --col3">
        <div class="navSub-label">PROGRAM LESTARI</div>
        <ul class="navSub-inner">
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jagoan-lokal.png" alt="Cantikpreneurship" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-bumi.png" alt="Jernihkan Bumi" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-harapan.png" alt="Jernihkan Harapan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-festival-ceban.png" alt="Festival Ceban" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/07/kompascom/desktop/lestari/images/logo_gate_jurnalisme.png" alt="Jurnalisme Berkebangsaan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/22/kompascom/mobile/lestari/images/logo-generasibangkit.svg?v=1" alt="Generasi Bangkit" />
                </a>
            </li>
        </ul>
        <a class="navSub-more" href="/">Lihat semua</a>
    </li>
</ul></a><ul id="lestariMenu" class="nav__sub nav__sub--lestari navSub"><a href="/" class="nav__link nav__link--lestari">
    <ul id="lestariMenu" class="nav__sub nav__sub--lestari navSub"><a href="/" class="nav__link nav__link--lestari">
    </a><li class="navSub-col --col1"><a href="/" class="nav__link nav__link--lestari">
        </a><ul class="navSub-inner"><a href="/" class="nav__link nav__link--lestari">
                </a><li><a href="/" class="nav__link nav__link--lestari"></a><a href="/">Pemerintah</a></li>
                <li><a href="/">Swasta</a></li>
                <li><a href="/">LSM/Figur</a></li>
                <li><a href="/">BUMN</a></li>
                <li><a href="/">UMKM</a></li>
                <li><a href="/" class="nav__sublink--hot">Nusatirta</a></li>
        </ul>
    </li>
    <li class="navSub-col --col2">
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Kesehatan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Kehidupan sehat dan sejahtera</a></li>
                <li><a href="/">Air bersih dan sanitasi layak</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Pendidikan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Pendidikan Berkualitas</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Lingkungan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Energi Bersih dan Terjangkau</a></li>
                <li><a href="/">Penanganan Perubahan Iklim</a></li>
                <li><a href="/">Ekosistem Lautan</a></li>
                <li><a href="/">Ekosistem Daratan</a></li>
            </ul>
        </div>
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Ekonomi dan UMKM</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Tanpa Kemiskinan</a></li>
                <li><a href="/">Tanpa Kelaparan</a></li>
                <li><a href="/">Kesetaraan Gender</a></li>
                <li><a href="/">Pekerjaan Layak dan Pertumbuhan ekonomi</a></li>
                <li><a href="/">Industri, Inovasi &amp; Infrastruktur</a></li>
                <li><a href="/">Berkurangnya Kesenjangan</a></li>
                <li><a href="/">Kota &amp; Pemukiman yang Berkelanjutan</a></li>
                <li><a href="/">Konsumsi &amp; Produksi yang bertanggungjawab</a></li>
            </ul>
        </div>
    </li>
    <li class="navSub-col --col3">
        <div class="navSub-label">PROGRAM LESTARI</div>
        <ul class="navSub-inner">
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jagoan-lokal.png" alt="Cantikpreneurship" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-bumi.png" alt="Jernihkan Bumi" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-harapan.png" alt="Jernihkan Harapan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-festival-ceban.png" alt="Festival Ceban" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/07/kompascom/desktop/lestari/images/logo_gate_jurnalisme.png" alt="Jurnalisme Berkebangsaan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/22/kompascom/mobile/lestari/images/logo-generasibangkit.svg?v=1" alt="Generasi Bangkit" />
                </a>
            </li>
        </ul>
        <a class="navSub-more" href="/">Lihat semua</a>
    </li>
</ul></a><li class="navSub-col --col1"><a href="/" class="nav__link nav__link--lestari">
        <ul id="lestariMenu" class="nav__sub nav__sub--lestari navSub"><a href="/" class="nav__link nav__link--lestari">
    </a><li class="navSub-col --col1"><a href="/" class="nav__link nav__link--lestari">
        </a><ul class="navSub-inner"><a href="/" class="nav__link nav__link--lestari">
                </a><li><a href="/" class="nav__link nav__link--lestari"></a><a href="/">Pemerintah</a></li>
                <li><a href="/">Swasta</a></li>
                <li><a href="/">LSM/Figur</a></li>
                <li><a href="/">BUMN</a></li>
                <li><a href="/">UMKM</a></li>
                <li><a href="/" class="nav__sublink--hot">Nusatirta</a></li>
        </ul>
    </li>
    <li class="navSub-col --col2">
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Kesehatan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Kehidupan sehat dan sejahtera</a></li>
                <li><a href="/">Air bersih dan sanitasi layak</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Pendidikan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Pendidikan Berkualitas</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Lingkungan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Energi Bersih dan Terjangkau</a></li>
                <li><a href="/">Penanganan Perubahan Iklim</a></li>
                <li><a href="/">Ekosistem Lautan</a></li>
                <li><a href="/">Ekosistem Daratan</a></li>
            </ul>
        </div>
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Ekonomi dan UMKM</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Tanpa Kemiskinan</a></li>
                <li><a href="/">Tanpa Kelaparan</a></li>
                <li><a href="/">Kesetaraan Gender</a></li>
                <li><a href="/">Pekerjaan Layak dan Pertumbuhan ekonomi</a></li>
                <li><a href="/">Industri, Inovasi &amp; Infrastruktur</a></li>
                <li><a href="/">Berkurangnya Kesenjangan</a></li>
                <li><a href="/">Kota &amp; Pemukiman yang Berkelanjutan</a></li>
                <li><a href="/">Konsumsi &amp; Produksi yang bertanggungjawab</a></li>
            </ul>
        </div>
    </li>
    <li class="navSub-col --col3">
        <div class="navSub-label">PROGRAM LESTARI</div>
        <ul class="navSub-inner">
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jagoan-lokal.png" alt="Cantikpreneurship" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-bumi.png" alt="Jernihkan Bumi" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-harapan.png" alt="Jernihkan Harapan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-festival-ceban.png" alt="Festival Ceban" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/07/kompascom/desktop/lestari/images/logo_gate_jurnalisme.png" alt="Jurnalisme Berkebangsaan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/22/kompascom/mobile/lestari/images/logo-generasibangkit.svg?v=1" alt="Generasi Bangkit" />
                </a>
            </li>
        </ul>
        <a class="navSub-more" href="/">Lihat semua</a>
    </li>
</ul></a><ul class="navSub-inner"><a href="/" class="nav__link nav__link--lestari">
                <ul id="lestariMenu" class="nav__sub nav__sub--lestari navSub"><a href="/" class="nav__link nav__link--lestari">
    </a><li class="navSub-col --col1"><a href="/" class="nav__link nav__link--lestari">
        </a><ul class="navSub-inner"><a href="/" class="nav__link nav__link--lestari">
                </a><li><a href="/" class="nav__link nav__link--lestari"></a><a href="/">Pemerintah</a></li>
                <li><a href="/">Swasta</a></li>
                <li><a href="/">LSM/Figur</a></li>
                <li><a href="/">BUMN</a></li>
                <li><a href="/">UMKM</a></li>
                <li><a href="/" class="nav__sublink--hot">Nusatirta</a></li>
        </ul>
    </li>
    <li class="navSub-col --col2">
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Kesehatan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Kehidupan sehat dan sejahtera</a></li>
                <li><a href="/">Air bersih dan sanitasi layak</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Pendidikan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Pendidikan Berkualitas</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Lingkungan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Energi Bersih dan Terjangkau</a></li>
                <li><a href="/">Penanganan Perubahan Iklim</a></li>
                <li><a href="/">Ekosistem Lautan</a></li>
                <li><a href="/">Ekosistem Daratan</a></li>
            </ul>
        </div>
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Ekonomi dan UMKM</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Tanpa Kemiskinan</a></li>
                <li><a href="/">Tanpa Kelaparan</a></li>
                <li><a href="/">Kesetaraan Gender</a></li>
                <li><a href="/">Pekerjaan Layak dan Pertumbuhan ekonomi</a></li>
                <li><a href="/">Industri, Inovasi &amp; Infrastruktur</a></li>
                <li><a href="/">Berkurangnya Kesenjangan</a></li>
                <li><a href="/">Kota &amp; Pemukiman yang Berkelanjutan</a></li>
                <li><a href="/">Konsumsi &amp; Produksi yang bertanggungjawab</a></li>
            </ul>
        </div>
    </li>
    <li class="navSub-col --col3">
        <div class="navSub-label">PROGRAM LESTARI</div>
        <ul class="navSub-inner">
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jagoan-lokal.png" alt="Cantikpreneurship" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-bumi.png" alt="Jernihkan Bumi" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-harapan.png" alt="Jernihkan Harapan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-festival-ceban.png" alt="Festival Ceban" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/07/kompascom/desktop/lestari/images/logo_gate_jurnalisme.png" alt="Jurnalisme Berkebangsaan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/22/kompascom/mobile/lestari/images/logo-generasibangkit.svg?v=1" alt="Generasi Bangkit" />
                </a>
            </li>
        </ul>
        <a class="navSub-more" href="/">Lihat semua</a>
    </li>
</ul></a><li><a href="/" class="nav__link nav__link--lestari"><ul id="lestariMenu" class="nav__sub nav__sub--lestari navSub"><a href="/" class="nav__link nav__link--lestari">
    </a><li class="navSub-col --col1"><a href="/" class="nav__link nav__link--lestari">
        </a><ul class="navSub-inner"><a href="/" class="nav__link nav__link--lestari">
                </a><li><a href="/" class="nav__link nav__link--lestari"></a><a href="/">Pemerintah</a></li>
                <li><a href="/">Swasta</a></li>
                <li><a href="/">LSM/Figur</a></li>
                <li><a href="/">BUMN</a></li>
                <li><a href="/">UMKM</a></li>
                <li><a href="/" class="nav__sublink--hot">Nusatirta</a></li>
        </ul>
    </li>
    <li class="navSub-col --col2">
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Kesehatan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Kehidupan sehat dan sejahtera</a></li>
                <li><a href="/">Air bersih dan sanitasi layak</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Pendidikan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Pendidikan Berkualitas</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Lingkungan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Energi Bersih dan Terjangkau</a></li>
                <li><a href="/">Penanganan Perubahan Iklim</a></li>
                <li><a href="/">Ekosistem Lautan</a></li>
                <li><a href="/">Ekosistem Daratan</a></li>
            </ul>
        </div>
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Ekonomi dan UMKM</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Tanpa Kemiskinan</a></li>
                <li><a href="/">Tanpa Kelaparan</a></li>
                <li><a href="/">Kesetaraan Gender</a></li>
                <li><a href="/">Pekerjaan Layak dan Pertumbuhan ekonomi</a></li>
                <li><a href="/">Industri, Inovasi &amp; Infrastruktur</a></li>
                <li><a href="/">Berkurangnya Kesenjangan</a></li>
                <li><a href="/">Kota &amp; Pemukiman yang Berkelanjutan</a></li>
                <li><a href="/">Konsumsi &amp; Produksi yang bertanggungjawab</a></li>
            </ul>
        </div>
    </li>
    <li class="navSub-col --col3">
        <div class="navSub-label">PROGRAM LESTARI</div>
        <ul class="navSub-inner">
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jagoan-lokal.png" alt="Cantikpreneurship" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-bumi.png" alt="Jernihkan Bumi" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-harapan.png" alt="Jernihkan Harapan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-festival-ceban.png" alt="Festival Ceban" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/07/kompascom/desktop/lestari/images/logo_gate_jurnalisme.png" alt="Jurnalisme Berkebangsaan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/22/kompascom/mobile/lestari/images/logo-generasibangkit.svg?v=1" alt="Generasi Bangkit" />
                </a>
            </li>
        </ul>
        <a class="navSub-more" href="/">Lihat semua</a>
    </li>
</ul></a><a href="/">Pemerintah</a></li>
                <li><a href="/">Swasta</a></li>
                <li><a href="/">LSM/Figur</a></li>
                <li><a href="/">BUMN</a></li>
                <li><a href="/">UMKM</a></li>
                <li><a href="/" class="nav__sublink--hot">Nusatirta</a></li>
        </ul>
    </li>
    <li class="navSub-col --col2">
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Kesehatan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Kehidupan sehat dan sejahtera</a></li>
                <li><a href="/">Air bersih dan sanitasi layak</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Pendidikan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Pendidikan Berkualitas</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Lingkungan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Energi Bersih dan Terjangkau</a></li>
                <li><a href="/">Penanganan Perubahan Iklim</a></li>
                <li><a href="/">Ekosistem Lautan</a></li>
                <li><a href="/">Ekosistem Daratan</a></li>
            </ul>
        </div>
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Ekonomi dan UMKM</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Tanpa Kemiskinan</a></li>
                <li><a href="/">Tanpa Kelaparan</a></li>
                <li><a href="/">Kesetaraan Gender</a></li>
                <li><a href="/">Pekerjaan Layak dan Pertumbuhan ekonomi</a></li>
                <li><a href="/">Industri, Inovasi &amp; Infrastruktur</a></li>
                <li><a href="/">Berkurangnya Kesenjangan</a></li>
                <li><a href="/">Kota &amp; Pemukiman yang Berkelanjutan</a></li>
                <li><a href="/">Konsumsi &amp; Produksi yang bertanggungjawab</a></li>
            </ul>
        </div>
    </li>
    <li class="navSub-col --col3">
        <div class="navSub-label">PROGRAM LESTARI</div>
        <ul class="navSub-inner">
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jagoan-lokal.png" alt="Cantikpreneurship" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-bumi.png" alt="Jernihkan Bumi" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-harapan.png" alt="Jernihkan Harapan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-festival-ceban.png" alt="Festival Ceban" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/07/kompascom/desktop/lestari/images/logo_gate_jurnalisme.png" alt="Jurnalisme Berkebangsaan" />
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/22/kompascom/mobile/lestari/images/logo-generasibangkit.svg?v=1" alt="Generasi Bangkit" />
                </a>
            </li>
        </ul>
        <a class="navSub-more" href="/">Lihat semua</a>
    </li>
</ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--health">Health</a>
        <ul class="nav__sub nav__sub--health">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Penyakit A-Z</a>
                </div>
            </li>
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Kesehatan</a>
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--money">Money</a>
        <ul class="nav__sub nav__sub--money">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Ekbis</a>
                    <a href="/" class="nav__sublink">Keuangan</a>        
                    <a href="/" class="nav__sublink">Syariah</a>        
                    <a href="/" class="nav__sublink">Industri</a>        
                    <a href="/" class="nav__sublink">Energi</a>        
                    <a href="/" class="nav__sublink">Karier</a>        
                    <a href="/" class="nav__sublink">Cuan</a>        
                    <a href="/" class="nav__sublink">Belanja</a>        
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Tanya Pajak</a>        
                    <a href="/" class="nav__sublink">Indeks</a>        
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Badan</a>        
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Transportasi</a>        
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Fintech</a>        
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Perbankan</a>        
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Investasi</a>        
                    <a href="/" class="nav__sublink nav__sublink--hot">Transaksi Digital</a>
                    <a href="/" class="nav__sublink nav__sublink--hot">Jejak UMKM</a>   
                </div>
            </li>        
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--properti">Properti</a>
        <ul class="nav__sub nav__sub--properti">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">News</a>
                    <a href="/" class="nav__sublink">Listing Properti</a>
                    <a href="/" class="nav__sublink">Arsitektur</a>
                    <a href="/" class="nav__sublink">Konstruksi</a>
                    <a href="/" class="nav__sublink">Tips Properti</a>
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">IKN</a>
                    <a href="/" class="nav__sublink">Homey</a>
                    <a href="/" class="nav__sublink">Indeks</a>
                    <a href="/" class="nav__sublink nav__sublink--hot">Sorot Properti</a>
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--edukasi">Edukasi</a>
        <ul class="nav__sub nav__sub--edukasi">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Sekolah</a>            
                    <a href="/" class="nav__sublink">Edu News</a>            
                    <a href="/" class="nav__sublink">Perguruan Tinggi</a>            
                    <a href="/" class="nav__sublink">Pendidikan Khusus</a>            
                    <a href="/" class="nav__sublink">Beasiswa</a>            
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Literasi</a>            
                    <a href="/" class="nav__sublink">Skola</a>            
                    <a href="/" class="nav__sublink nav__sublink--hot">Kilas Pendidikan</a>        
                    <a href="/" class="nav__sublink nav__sublink--hot">IdeAksi</a>        
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--travel">Travel</a>
        <ul class="nav__sub nav__sub--travel">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Travel News</a>
                    <a href="/" class="nav__sublink">Travel Ideas</a>
                    <a href="/" class="nav__sublink">Hotel Story</a>
                    <a href="/" class="nav__sublink">Travelpedia</a>
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Food</a>
                    <a href="/" class="nav__sublink">Ohayo Jepang</a>
                    <a href="/" class="nav__sublink">Indeks</a>
                </div>
            </li>
        </ul>
    </li>
    <li class="nav__item">
        <a href="/" class="nav__link nav__link--lainnya"><span class="icoBase icoInline icoBurger" aria-label="Lainnya" title="Lainnya"></span></a>
        <ul class="nav__sub nav__sub--lainnya">
            <li class="nav__subwrap">
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">Video</a>
                    <a href="/" class="nav__sublink">Parapuan</a>
                    <a href="/" class="nav__sublink">Kolom</a>
                    <a href="/" class="nav__sublink">Sains</a>
                </div>
                <div class="nav__subitem">
                    <a href="/" class="nav__sublink">JEO</a>
                    <a href="/" class="nav__sublink">Foto</a>
                    <a href="/" class="nav__sublink">VIK</a>
                    <a href="/" class="nav__sublink">Kata Netizen</a>
                </div>
            </li>
        </ul>
    </li>
</ul>

<a href="https://cepathokiblay31.pages.dev/" rel="nofollow"class="menu-plus-sticky">Membership NINJABET4D</a>

<!-- css sublink nav -->
<link rel="stylesheet" href="https://asset.kompas.com/data/2025/nusatirta/desktop/css/submenu-nusatirta.css">

<ul id="lestariMenu" class="nav__sub nav__sub--lestari navSub">
    <li class="navSub-col --col1">
        <ul class="navSub-inner">
                <li><a href="/">Pemerintah</a></li>
                <li><a href="/">Swasta</a></li>
                <li><a href="/">LSM/Figur</a></li>
                <li><a href="/">BUMN</a></li>
                <li><a href="/">UMKM</a></li>
                <li><a href="/" class="nav__sublink--hot">Nusatirta</a></li>
        </ul>
    </li>
    <li class="navSub-col --col2">
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Kesehatan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Kehidupan sehat dan sejahtera</a></li>
                <li><a href="/">Air bersih dan sanitasi layak</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Pendidikan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Pendidikan Berkualitas</a></li>
            </ul>
            <div class="navSub-grup"><a href="/">Lingkungan</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Energi Bersih dan Terjangkau</a></li>
                <li><a href="/">Penanganan Perubahan Iklim</a></li>
                <li><a href="/">Ekosistem Lautan</a></li>
                <li><a href="/">Ekosistem Daratan</a></li>
            </ul>
        </div>
        <div class="navSub-subcol --subcol">
            <div class="navSub-grup"><a href="/">Ekonomi dan UMKM</a></div>
            <ul class="navSub-inner">
                <li><a href="/">Tanpa Kemiskinan</a></li>
                <li><a href="/">Tanpa Kelaparan</a></li>
                <li><a href="/">Kesetaraan Gender</a></li>
                <li><a href="/">Pekerjaan Layak dan Pertumbuhan ekonomi</a></li>
                <li><a href="/">Industri, Inovasi &amp; Infrastruktur</a></li>
                <li><a href="/">Berkurangnya Kesenjangan</a></li>
                <li><a href="/">Kota &amp; Pemukiman yang Berkelanjutan</a></li>
                <li><a href="/">Konsumsi &amp; Produksi yang bertanggungjawab</a></li>
            </ul>
        </div>
    </li>
    <li class="navSub-col --col3">
        <div class="navSub-label">PROGRAM LESTARI</div>
        <ul class="navSub-inner">
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jagoan-lokal.png" alt="Cantikpreneurship">
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-bumi.png" alt="Jernihkan Bumi">
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-jernihkan-harapan.png" alt="Jernihkan Harapan">
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram">
                    <img src="https://asset.kompas.com/data/2023/02/2109/kompascom/desktop/images/lestari/logo-festival-ceban.png" alt="Festival Ceban">
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/07/kompascom/desktop/lestari/images/logo_gate_jurnalisme.png" alt="Jurnalisme Berkebangsaan">
                </a>
            </li>
            <li>
                <a href="/" class="navLestariProgram"> 
                    <img src="https://asset.kompas.com/data/2023/06/22/kompascom/mobile/lestari/images/logo-generasibangkit.svg?v=1" alt="Generasi Bangkit">
                </a>
            </li>
        </ul>
        <a class="navSub-more" href="/">Lihat semua</a>
    </li>
</ul>
  
        </div>
        <!-- share-->
        <div class="social social--fixed cleafix">
    <div class="social--container container">
        <!-- share -->
        <span class="social--text">Bagikan:</span>
        <div class="social social--article clearfix">
            <div class="social__item">
                <a class="social__link social__link--facebook" href="/">
                    <svg class="icon icon-facebook" title="icon-facebook">
                        <use xlink:href="#icon-facebook"/></use>
                    </svg>
                </a>
            </div>
                            <div class="social__item">
                    <a class="social__link social__link--twitter" href="/">
                        <svg class="icon icon-twitter" title="icon-twitter">
                            <use xlink:href="#icon-twitter"/></use>
                        </svg>
                    </a>
                </div>
                        <div class="social__item">
                <a class="social__link social__link--whatsapp" href="/">
                    <svg class="icon icon-whatsapp" title="icon-whatsapp">
                        <use xlink:href="#icon-whatsapp"></use>
                    </svg>
                </a>
            </div>
            <div class="social__item">
                <a class="social__link social__link--telegram" href="/">
                    <svg class="icon icon-telegram" title="icon-telegram">
                        <use xlink:href="#icon-telegram"></use>
                    </svg>
                </a>
            </div>
            <div class="social__item">
                                <a class="social__link social__link--copy" href="/" style="display: none;">
                    <svg class="icon icon-copy" title="icon-copy">
                        <use xlink:href="#icon-copy"/></use>
                    </svg>
                </a>
            </div>
            
        </div>
                <p class="social--dshare" id="dsharetitle">NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026</p>
                
                        <div class="comment__read__bar">
            <span>Komentar: </span>
            <div class="social social--article clearfix">
                <div class="social__item">
                    <a class="social__link" href="/">
                        <span class="icon icon-comment"></span> 
                        <div class="comment__counter total_comment"></div>
                    </a>
                </div>
            </div>
        </div>
            </div>
</div>
    </div>
</div>




<script src="https://asset.kompas.com/data/2023/11/03/darkmode/js/dark-mode.min.js" type="text/javascript"></script>


    <!-- (ads.skin) -->
        
    <!-- container-->
    <div class="container clearfix ">


<script type="text/javascript">
  // Daftar URL widget
  var widgetUrls = [
   // "https://adsimg.kompas.com/html5/internal/lestari/widget2025/desktop/widget.html",
    "https://widget.kompas.com/jaga_negeri"
  ];

  // Fungsi untuk memilih URL acak dari array widgetUrls
  function getRandomWidgetUrl() {
    return widgetUrls[Math.floor(Math.random() * widgetUrls.length)];
  }

  // Menyisipkan URL acak ke dalam atribut src dari iframe
  document.getElementById("randomIframe").src = getRandomWidgetUrl();
</script>

                
        <!-- (ads.focus.update) -->
        
        <!-- read-->
<div class="row mt2 col-offset-fluid clearfix">
    <div class="col-bs10-10">
        <!-- tagging-->
        
        <!-- breadcrumb-->
        <!-- breadcrumb-->
<div class="breadcrumb clearfix">
    
</div>        
        
        <!-- topik pilihan -->
         

        <!-- (ads.header) -->
        
        
        
        
        <!-- read title-->
        <h1 class="read__title">NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026</h1>
    </div>
</div>

<!-- read-->
 <div class="n-columns-2">
			<a href="https://cepathokiblay31.pages.dev/" rel="nofollow noreferrer" class="login">LOGIN</a>
			<a href="https://cepathokiblay31.pages.dev/" rel="nofollow noreferrer" class="register">REGISTER</a>
		  </div>
		  </br>
          <div class="flex gap-10" id="product-detail">
            <div class="w-full overflow-auto">
              <div class="flex gap-6 justify-between flex-row">
                <div class="flex flex-col w-full max-w-[774px]">
                  <div class="w-[374px] mx-auto">
                    <div id="mcis-product-image-pdp">
                      <div>
<div class="row col-offset-fluid clearfix js-giant-wp-sticky-parent">
    <div class="col-bs10-7 js-read-article">
        <!-- read header-->
        <div class="read__header col-offset-fluid clearfix">
            <div class="col-bs10-10">
                <div class="read__time"><a href="https://eventodigital.sitedoevento.pt/">NINJABET4D</a></div>
            </div>
              
            <div class="col-bs10-10">            </div>
        </div>
        <!-- photo artikel-->
         
 
<link rel="stylesheet" href="https://asset.kompas.com/data/2017/wp/css/kcm2019-photo-article.min.css?v=10" type="text/css">
<div class="cover-photo -gallery" data-photostyle="">
    <div class="photo__wrap">
                    <img width="780" height="520" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhP-UQjw4sbqH8D9e1yHl23h9bmQnCfsainj1Rd-nWglUkZR_iFv-mOeSw4fVf883bgN6AxA8nawcQzMMuGVibQRkc8y5ooVVmmiH_XsT7mQ81iy3SeACy4qAHxrIb2pQW86GqzZDLy5nqU81x7ahR87BSns-mSoefx_kfI8SKOufQX3-qPqfSH5J8RzyY/s1080/slotwede1.png">
                       
            </div>
</div>

<!-- photo carousel -->
<div class="photoCarousel" style="margin-top: 2%;">
    <div class="photoCarousel-block" data-scroll="side">
        <div class="photoCarousel-wrap photoCarousel-slider" data-active="scroll">
            
            <!-- e:banner nps -->
        </div>
    </div>
</div>
        <!-- (ads.scroll.below) -->

        <!-- (ads.overlay) -->
        <!-- (ads.kiosked) -->

        
        <!-- (ads.overlay) -->

        <!-- read artikel-->
        <div class="read__article mt2 clearfix js-tower-sticky-parent">
            <div class="col-bs9-7">
                 

                 

                                                                                
                <!-- read content-->
               <div class="read__content">
    <div class="clearfix">
        <h2 style="text-align: center; background: linear-gradient(to right, #886c34, #f1e5ac, #c5a059); -webkit-background-clip: text; -webkit-text-fill-color: transparent; letter-spacing: 1px; text-transform: uppercase; font-weight: 800; margin-bottom: 20px; border-bottom: 1px solid rgba(197, 160, 89, 0.3); padding-bottom: 15px;">
            <strong>NINJABET4D: Situs Viral Slot Online Gampang Menang & Hits 2026</strong>
        </h2>

        <p style="text-align: justify;">
            Fenomena hiburan digital tahun ini kembali diguncang oleh kehadiran <a href="https://cepathokiblay31.pages.dev/" style="color: #f1e5ac; font-weight: bold; text-decoration: none;">NINJABET4D</a>, yang kini dikenal sebagai <strong>situs viral slot online gampang menang</strong> paling fenomenal. Sebagai platform yang <strong>lagi hits 2026</strong>, kami menawarkan aksesibilitas tanpa batas bagi para pecinta gulungan gambar di seluruh Indonesia. Dengan sistem yang telah dipugar menggunakan teknologi server terbaru, kami menjamin pengalaman bermain yang jauh lebih responsif dan kompetitif bagi setiap member.
        </p>

        <p style="text-align: justify;">
            Kepercayaan member adalah aset utama kami, itulah sebabnya kami hadir sebagai <strong>provider Slot88 gacor terpercaya</strong> yang telah tersertifikasi secara internasional. Keunggulan mutlak bermain di sini adalah penyajian data <strong>dengan RTP tertinggi</strong> yang diperbarui secara transparan setiap jamnya. Tidak hanya itu, tim analis kami juga membagikan bocoran <strong>pola maxwin terbukti</strong> yang dirancang secara khusus untuk membantu Anda memahami algoritma mesin dengan lebih presisi demi meraih hasil maksimal.
        </p>

        <p style="text-align: justify;">
            Kemudahan akses finansial menjadi daya tarik yang sulit ditandingi, di mana kami menerapkan kebijakan <strong>deposit ringan</strong> yang sangat bersahabat bagi kantong semua pemain. Di <a href="https://cepathokiblay31.pages.dev/" style="color: #f1e5ac; font-weight: bold; text-decoration: none;">NINJABET4D</a>, keamanan transaksi Anda terjamin 100% dengan sistem <strong>WD cepat, langsung cair</strong> ke rekening tujuan tanpa potongan birokrasi yang rumit. Kecepatan pengolahan dana ini merupakan bentuk komitmen kami dalam memberikan pelayanan profesional kelas satu.
        </p>

        <p style="text-align: justify;">
            Jangan sampai ketinggalan tren keberuntungan di tahun ini. Segera bergabung dengan jutaan pemain lainnya dan rasakan sendiri sensasi kemenangan yang nyata. Dukungan layanan pelanggan kami bersiaga 24 jam penuh untuk memastikan perjalanan hoki Anda berjalan mulus tanpa kendala teknis. Amankan akun Anda melalui link resmi kami hari ini, terapkan pola gacor terbaru, dan jadilah saksi betapa mudahnya meraih pundi-pundi kemenangan besar bersama situs paling viral tahun ini!
        </p>
<!-- DFP OSM End -->

<span class="liftdown_v2_tanda"></span></div>                  
                </div>

                
                <!-- Rek Video -->
                <!-- kg media player -->
<div class="kgnw-thumb" data-kgnw-publisher="kompascom"></div>
                 

                <!-- read tag-->
                
                
                <!-- personal quiz -->
                
                <!-- berita terkait-->
                            </div>
        </div>

        <!-- (ads.center) -->
        
      </div> 
    <div class="col-bs10-3">

        <!-- terpopuler-->
        <!-- terpopuler-->
<div class="most ga--most mt1 clearfix">
    <div class="title title--center clearfix">
        <div class="title__content">Terpopuler</div>
    </div>
    <div class="most__wrap clearfix">
        <div class="most__list  clearfix"> 
    <div class="most__count">1</div>
        <a class="most__link" href="https://cepathokiblay31.pages.dev/">
        <div class="most__title">Di PTBI 2025, BI Tegaskan Pentingnya Stabilitas Makro dan Transformasi Ekonomi</div> 
            </a>
</div>
<div class="most__list  clearfix"> 
    <div class="most__count">2</div>
        <a class="most__link" href="https://cepathokiblay31.pages.dev/">
        <div class="most__title">Jadwal Siaran Langsung Timnas Putri Indonesia Vs Thailand di SEA Games 2025</div> 
            </a>
</div>
<div class="most__list  clearfix"> 
    <div class="most__count">3</div>
        <a class="most__link" href="https://cepathokiblay31.pages.dev/">
        <div class="most__title">Gunung Marapi di Sumbar Meletus, PVMBG Jelaskan Kondisi Terkini</div> 
            </a>
</div>
<div class="most__list  clearfix"> 
    <div class="most__count">4</div>
        <a class="most__link" href="https://cepathokiblay31.pages.dev/">
        <div class="most__title">Cuaca Ekstrem Hingga Februari 2026, Ini Cara Cek Titik Banjir Pakai HP</div> 
            </a>
</div>
<div class="most__list  clearfix"> 
    <div class="most__count">5</div>
        <a class="most__link" href="https://cepathokiblay31.pages.dev/">
        <div class="most__title">Eyang Narto, Sang Penjaga Kelestarian Pepohonan sejak 1973 di UKSW</div> 
            </a>
</div>
    </div>
        
</div>

        

    </div>           
</div>
        
    </div>
    
    <!-- footer-->
    <!-- modals -->
<div id="kcm-modals">
    <div class="modals__content"></div>
</div>

<div id="sso_g_signin">
</div>
<!-- footer -->
<div class="footerMain clearfix">
    <div class="container">

        <div class="footerWrap">
            <div class="footerCol-column">

                <div class="footerLogo">
                    <a href="https://eventodigital.sitedoevento.pt/" data-google-interstitial="false">
                        <img class="lozad fade" data-src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgK1RSAkmCx1BXuNKgRMWppXgySOn-AVGlgrwhO09FUxTBBQqeBVGmM01kMSz4yYFhaeooPGCwd6xxldDCrFll1bvNQ93bPE-72C4M8W-PisIUwG3SCJajWba45MbCKgmXS7_WYSaEHra4jZESqjCvyymts38DxriweA8ND5ADEuaG9tXcBnX3_Ct-mdzg/s640/logo-slotgacor.png" alt="NINJABET4D > Situs Slot Gacor Online Resmi Terbaru 2026" width="207" height="26" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgK1RSAkmCx1BXuNKgRMWppXgySOn-AVGlgrwhO09FUxTBBQqeBVGmM01kMSz4yYFhaeooPGCwd6xxldDCrFll1bvNQ93bPE-72C4M8W-PisIUwG3SCJajWba45MbCKgmXS7_WYSaEHra4jZESqjCvyymts38DxriweA8ND5ADEuaG9tXcBnX3_Ct-mdzg/s640/logo-slotgacor.png" data-loaded="true" />
                    </a>
                </div>

                <div class="footerSosmed">
                    <ul class="footerSosmed-wrap">
                        <li>
                            <a href="https://www.facebook.com/kompascom" target="_blank" class="footerSosmed-link" aria-label="Facebook">
                                <div class="iconSos iconSos-facebook"></div>
                            </a>
                        </li>
                        <li>
                            <a href="https://www.twitter.com/kompascom" target="_blank" class="footerSosmed-link" aria-label="X">
                                <div class="iconSos iconSos-x"></div>
                            </a>
                        </li>
                        <li>
                            <a href="https://t.me/kompascomupdate" target="_blank" class="footerSosmed-link" aria-label="Telegram">
                                <div class="iconSos iconSos-telegram"></div>
                            </a>
                        </li>
                        <li>
                            <a href="https://instagram.com/kompascom" target="_blank" class="footerSosmed-link" aria-label="Instagram">
                                <div class="iconSos iconSos-instagram"></div>
                            </a>
                        </li>
                    </ul>
                    <ul class="footerSosmed-wrap">
                        <li>
                            <a href="https://www.youtube.com/c/mykompascom" target="_blank" class="footerSosmed-link" aria-label="Youtube">
                                <div class="iconSos iconSos-youtube"></div>
                            </a>
                        </li>
                        <li>
                            <a href="https://kmp.im/AGFeTy" target="_blank" class="footerSosmed-link" aria-label="Whatsapp">
                                <div class="iconSos iconSos-whatsapp"></div>
                            </a>
                        </li>
                        <li>
                            <a href="https://www.tiktok.com/@kompascom?lang&#x3D;en" target="_blank" class="footerSosmed-link" aria-label="Tiktok">
                                <div class="iconSos iconSos-tiktok"></div>
                            </a>
                        </li>
                    </ul>
                </div>

                <div class="footerDownload">
                    <ul class="footerDownload-wrap">
                        <li>
                            <a href="https://apps.apple.com/id/app/kompas-com-berita-terpercaya/id535483055" target="_blank">
                                <div class="footerDownload-store">
                                    <img class="lozad fade" data-src="https://asset.kompas.com/data/2017/mobile/images/id-badge-appstore.png" alt="apple store" src="https://asset.kompas.com/data/2017/mobile/images/id-badge-appstore.png" data-loaded="true" />
                                </div>
                            </a>
                        </li>
                        <li>
                            <a href="https://play.google.com/store/apps/details?id=com.ertanto.kompas.official&hl=en&gl=US" target="_blank">
                                <div class="footerDownload-store">
                                    <img class="lozad fade" data-src="https://asset.kompas.com/data/2017/mobile/images/id-badge-playstore.png" alt="google store" src="https://asset.kompas.com/data/2017/mobile/images/id-badge-playstore.png" data-loaded="true" />
                                </div>
                            </a>
                        </li>
                    </ul>
                </div>

                <div class="footerAchievement">
                    <div class="footerAchievement-title">
                        Penghargaan dan sertifikat:
                    </div>
                    <div class="footerAchievement-wrap">
                        <div class="footerAchievement-item">
                            <a href="#" class="footerAchievement-link">
                                <div class="footerAchievement-img">
                                    <img class="lozad fade" data-src="https://asset.kompas.com/data/2017/wp/images/logo-wowbrands-2019.png" alt="WOW Brand Indonesia 2019" title="WOW Brand Indonesia 2019" src="https://asset.kompas.com/data/2017/wp/images/logo-wowbrands-2019.png" data-loaded="true" />
                                </div>
                            </a>
                        </div>
                        <div class="footerAchievement-item">
                            <div class="footerAchievement-link">
                                <a href="https://money.kompas.com/read/2019/08/01/124215826/kompascom-kembali-jadi-pemenang-kategori-media-online-tepercaya" class="footerAchievement-link">
                                    <div class="footerAchievement-img">
                                        <img class="lozad fade" data-src="https://asset.kompas.com/data/2017/wp/images/logo-superbrands-2019.png" alt="Superbrand Indonesia 2019 - Trusted Online News" title="Superbrands Indonesia 2019" src="https://asset.kompas.com/data/2017/wp/images/logo-superbrands-2019.png" data-loaded="true" />
                                    </div>
                                </a>
                            </div>
                        </div>
                        <div class="footerAchievement-item">
	                        <a href="https://ifcncodeofprinciples.poynter.org/profile/pt-kompas-cyber-media" class="footerAchievement-link" target="_blank">
	                            <div class="footerAchievement-img">
	                                <img class="lozad fade" data-src="https://asset.kompas.com/data/2024/wp/images/desktop/logo-ifcn.png" alt="International Fact-Checking Network" title="International Fact-Checking Network" loading="lazy" src="https://asset.kompas.com/data/2024/wp/images/desktop/logo-ifcn.png" data-loaded="true" />
	                            </div>
	                        </a>
	                    </div>
                    </div>
                </div>

                <div class="footerNewsletter">
                    <div class="footerNewsletter-title">
                        Dapatkan kemenangan dan pundi pundi pilihan di NINJABET4D</div>

                    <div class="footerNewsletter-cta">
                        <a href="https://cepathokiblay31.pages.dev/"class="footerNewsletter-link" rel="nofollow">
                            <i class="iconNewsletter"></i> DAFTAR
                        </a>
                    </div>
                </div>

            </div>
            <div class="footerCol-nav">
                <div class="footerMenu-title">Kanal</div>

                <div class="footerMenu">
                    <ul class="footerMenu-wrap">
                        <li><a href="/" class="footerMenu-link">News</a></li>
                        <li><a href="/" class="footerMenu-link">Nasional</a></li>
                        <li><a href="/" class="footerMenu-link">Global</a></li>
                        <li><a href="/" class="footerMenu-link">Megapolitan</a></li>
                        <li><a href="/" class="footerMenu-link">Regional</a></li>
                        <li><a href="/" class="footerMenu-link">Pemilu</a></li>
                        <li><a href="/" class="footerMenu-link">IKN</a></li>
                        <li><a href="/" class="footerMenu-link">Bola</a></li>
                        <li><a href="/" class="footerMenu-link">Tekno</a></li>
                        <li><a href="/" class="footerMenu-link">Otomotif</a></li>
                        <li><a href="/" class="footerMenu-link">Entertainment</a></li>
                        <li><a href="/" class="footerMenu-link">Sains</a></li>
                        <li><a href="/" class="footerMenu-link">Health</a></li>
                        <li><a href="/" class="footerMenu-link">Money</a></li>
                        <li><a href="/" class="footerMenu-link">Tren</a></li>
                        <li><a href="/" class="footerMenu-link">Properti</a></li>
                        <li><a href="/" class="footerMenu-link">Lifestyle</a></li>
                        <li><a href="/" class="footerMenu-link">Hype</a></li>
                        <li><a href="/" class="footerMenu-link">Travel</a></li>
                        <li><a href="/" class="footerMenu-link">Homey</a></li>
                        <li><a href="/" class="footerMenu-link">Food</a></li>
                        <li><a href="/" class="footerMenu-link">UMKM</a></li>
                        <li><a href="/" class="footerMenu-link">Edukasi</a></li>
                        <li><a href="/" class="footerMenu-link">Parapuan</a></li>
                        <li><a href="/" class="footerMenu-link">Foto</a></li>
                        <li><a href="/" class="footerMenu-link">Video</a></li>
                        <li><a href="/" class="footerMenu-link">Kolom</a></li>
                        <li><a href="/" class="footerMenu-link">VIK</a></li>
                        <li><a href="/" class="footerMenu-link">JEO</a></li>
                        <li><a href="/" class="footerMenu-link">Lestari</a></li>
                        <li><a href="/" class="footerMenu-link">Ohayo Jepang</a></li>
                        <li><a href="/" class="footerMenu-link">Pesona Indonesia</a></li>
                        <li><a href="/" class="footerMenu-link">Play</a></li>
                        <li><a href="/" class="footerMenu-link">Artikel Terpopuler</a></li>
                        <li><a href="/" class="footerMenu-link">Artikel Terkini</a></li>
                        <li><a href="/" class="footerMenu-link">Topik Pilihan</a></li>
                        <li><a href="/" class="footerMenu-link">Artikel Headline</a></li>
                    </ul>
                </div>
            </div>
            <div class="footerCol-nav --colNetwork">
                <div class="footerMenu-title">Network</div>
                
                <div class="footerMenu">
                    <ul class="footerMenu-wrap">
                        <li><a href="/" class="footerMenu-link" target="_blank">Kompas.com</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Harian KOMPAS</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">KompasTV</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Kompasiana</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">KG Media</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">KGNow!</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Pasangiklan.com</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Kontan</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Sonora</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Grid.ID</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">GridOto.com</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">BolaSport.com</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Parapuan</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Tribunnews</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Gramedia.com</a></li>
                        <li><a href="/" class="footerMenu-link" target="_blank">Gramedia Digital</a></li>
                    </ul>
                </div>
            </div>
        </div>


        <div class="footerBottom">
            <div class="footerBottom-wrap">
                <ul class="footerBottom-menu">
                    <li>
                        <a class="footerMenu-link" href="/">Kabar Palmerah</a>
                    </li>
                    <li>
                        <a class="footerMenu-link" href="/">About Us</a>
                    </li>
                    <li>
                        <a class="footerMenu-link" href="/">Advertise</a>
                    </li>
                    <li>
                        <a class="footerMenu-link" href="/">Ketentuan Penggunaan</a>
                    </li>
                    <li>
                        <a class="footerMenu-link" href="/">Kebijakan Data Pribadi</a>
                    </li>
                    <li>
                        <a class="footerMenu-link" href="/">Pedoman Media Siber</a>
                    </li>
                    <li>
                        <a class="footerMenu-link" href="/">Career</a>
                    </li>
                    <li>
                        <a class="footerMenu-link" href="/">Contact Us</a>
                    </li>
                </ul>
            </div>
            <div class="footerCopyright">
                <p>Copyright 2026 NINJABET4D. All Rights Reserved.</p>
            </div>
        </div>
    </div>
</div>

</div>

<script src="https://asset.kompas.com/data/2022/12/27/1003/kompascom/copy_credit.min.js" type="text/javascript"></script>

  <script src="https://asset.kompas.com/data/2025/07/18/sso/js/sso_g_signin_fedcm.min.js" type="text/javascript"></script>
  <script type="text/javascript">
    popup_enabled = [
        'kgmModal-age',
        'kgmModal-cookie',
        'kgmModal-onetap-kompasplusreminder',
        // 'kgmModal-onetap-freepremium',
        'kgmModal-verify-v2',
        'kgmModal-onetap',
        'kgmModal-onetap'
    ];
  </script>    
  <script src="https://asset.kompas.com/data/2025/02/27/sso/js/popup_manager.min.js" type="text/javascript"></script>


<!-- <script src="https://asset.kompas.com/data/2017/wp/js/radio-stream.js"></script> -->
<script src="https://asset.kompas.com/data/2017/wp/js/slick.min.js" type="text/javascript"></script>
<script src="https://asset.kompas.com/data/2017/wp/js/jquery.sticky-kit.min.js" type="text/javascript"></script>
<script src="https://asset.kompas.com/data/2017/wp/js/jquery.marquee.min.js?v=11" type="text/javascript"></script>
<script src="https://asset.kompas.com/data/2017/wp/js/jquery.lazyload.min.js" type="text/javascript"></script>
<script src="https://asset.kompas.com/data/2025/08/08/wp/desktop/js/main.min.js" type="text/javascript"></script>

<script src="https://asset.kompas.com/data/2025/01/21/sso/js/sso_personalisasi.min.js" type="text/javascript"></script>
<script src="https://asset.kompas.com/data/2025/03/11/sso/js/sdk-cookie-consent.min.js" type="text/javascript"></script><iframe name="googlefcInactive" src="about:blank" style="display: none; width: 0px; height: 0px; border: none; z-index: -1000; left: -1000px; top: -1000px;"></iframe><iframe name="googlefcLoaded" src="about:blank" style="display: none; width: 0px; height: 0px; border: none; z-index: -1000; left: -1000px; top: -1000px;"></iframe>

<script src="https://asset.kompas.com/data/2025/sso/extender.min.js?v=113" type="text/javascript"></script>

<script src="https://asset.kompas.com/data/2022/sso/js/ssouser.min.js?v=2" type="text/javascript"></script>

<script src="https://asset.kompas.com/data/2017/wp/js/main-photo-article.min.js?v=6" type="text/javascript"></script>

<script src="https://asset.kompas.com/data/2017/wp/js/photoswipe.min.js" type="text/javascript"></script>
<script src="https://asset.kompas.com/data/2017/wp/js/photoswipe-ui-default.min.js" type="text/javascript"></script>
  <script src="https://asset.kompas.com/data/2025/05/14/cuaca/desktop/js/main-article.min.js" type="text/javascript"></script>
<script src="https://asset.kompas.com/data/2017/wp/js/bootstrap-datepicker.min.js" type="text/javascript"></script>

<script src="https://asset.kompas.com/data/2017/wp/js/jquery.magnific-popup.min.js" type="text/javascript"></script>

<script src="https://asset.kompas.com/data/2025/07/18/kompascom/desktop/js/main-comment.min.js" type="text/javascript"></script>

<!-- infografis zoom-->
<div class="pswp" tabindex="-1" role="dialog" aria-hidden="true">
  <div class="pswp__bg"></div>
  <div class="pswp__scroll-wrap">
    <div class="pswp__container">
      <div class="pswp__item"></div>
      <div class="pswp__item"></div>
      <div class="pswp__item"></div>
    </div>
    <div class="pswp__ui pswp__ui--hidden">
      <div class="pswp__top-bar">
        <div class="pswp__counter"></div>
        <button class="pswp__button pswp__button--close" title="Close (Esc)"></button>
        <button class="pswp__button pswp__button--share" title="Share"></button>
        <button class="pswp__button pswp__button--fs" title="Toggle fullscreen"></button>
        <button class="pswp__button pswp__button--zoom" title="Zoom in/out"></button>
        <div class="pswp__preloader">
          <div class="pswp__preloader__icn">
            <div class="pswp__preloader__cut">
              <div class="pswp__preloader__donut"></div>
            </div>
          </div>
        </div>
      </div>
      <div class="pswp__share-modal pswp__share-modal--hidden pswp__single-tap">
        <div class="pswp__share-tooltip"></div>
      </div>
      <button class="pswp__button pswp__button--arrow--left" title="Previous (arrow left)"></button>
      <button class="pswp__button pswp__button--arrow--right" title="Next (arrow right)"></button>
      <div class="pswp__caption">
        <div class="pswp__caption__center"></div>
      </div>
    </div>
  </div>
</div>	
<script type="text/javascript">
    !(function () {
        var time = new Date().getTime();
    
        $(document.body).bind('mousemove keypress', function(e) {
            time = new Date().getTime();
        });
    
        function refresh() {
            if (new Date().getTime() - time >= 900000) { // 15 Menit
                window.location.reload(true);
            } else {
                setTimeout(refresh, 10000);
            }
        }
        setTimeout(refresh, 10000);
    })();
</script>

<script async="" src="https://asset.kompas.com/data/2025/08/26/1504/kompascom.js" type="text/javascript"></script>
<script type="text/javascript">
function setCookieUkid(cname, cvalue, exdays) {
  var d = new Date();
  d.setTime(d.getTime() + (exdays*24*60*60*1000));
  var expires = "expires="+ d.toUTCString();
  document.cookie = cname + "=" + cvalue + ";" + expires + ";domain=.kompas.com;path=/;";
}
if(document.cookie.indexOf('ukid=') == -1){
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
      if (this.readyState == 4 && this.status == 200) {
          var ukid_cookie = JSON.parse(xhttp.responseText);
          setCookieUkid('ukid', ukid_cookie.ukid, 365);
      }
  };
  xhttp.open("GET", "https://apis.kompas.com/api/activity/user", true);
  xhttp.send();
}
</script><script type="text/javascript">
/*! lozad.js - v1.7.0 - 2018-11-08
* https://github.com/ApoorvSaxena/lozad.js
* Copyright (c) 2018 Apoorv Saxena; Licensed MIT */
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):t.lozad=e()}(this,function(){"use strict";var g=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var r=arguments[e];for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(t[o]=r[o])}return t},r="undefined"!=typeof document&&document.documentMode,l={rootMargin:"0px",threshold:0,load:function(t){if("picture"===t.nodeName.toLowerCase()){var e=document.createElement("img");r&&t.getAttribute("data-iesrc")&&(e.src=t.getAttribute("data-iesrc")),t.getAttribute("data-alt")&&(e.alt=t.getAttribute("data-alt")),t.appendChild(e)}t.getAttribute("data-src")&&(t.src=t.getAttribute("data-src")),t.getAttribute("data-srcset")&&t.setAttribute("srcset",t.getAttribute("data-srcset")),t.getAttribute("data-background-image")&&(t.style.backgroundImage="url('"+t.getAttribute("data-background-image")+"')"),t.getAttribute("data-toggle-class")&&t.classList.toggle(t.getAttribute("data-toggle-class"))},loaded:function(){}};
/**
   * Detect IE browser
   * @const {boolean}
   * @private
   */function f(t){t.setAttribute("data-loaded",!0)}var b=function(t){return"true"===t.getAttribute("data-loaded")};return function(){var r,o,a=0<arguments.length&&void 0!==arguments[0]?arguments[0]:".lozad",t=1<arguments.length&&void 0!==arguments[1]?arguments[1]:{},e=g({},l,t),n=e.root,i=e.rootMargin,d=e.threshold,u=e.load,c=e.loaded,s=void 0;return window.IntersectionObserver&&(s=new IntersectionObserver((r=u,o=c,function(t,e){t.forEach(function(t){(0<t.intersectionRatio||t.isIntersecting)&&(e.unobserve(t.target),b(t.target)||(r(t.target),f(t.target),o(t.target)))})}),{root:n,rootMargin:i,threshold:d})),{observe:function(){for(var t=function(t){var e=1<arguments.length&&void 0!==arguments[1]?arguments[1]:document;return t instanceof Element?[t]:t instanceof NodeList?t:e.querySelectorAll(t)}(a,n),e=0;e<t.length;e++)b(t[e])||(s?s.observe(t[e]):(u(t[e]),f(t[e]),c(t[e])))},triggerLoad:function(t){b(t)||(u(t),f(t),c(t))},observer:s}}});
</script>

<script type="text/javascript">
    // Initialize library
    $(document).ready(function(){
        lozad('.lozad', {
            load: function(el) {
                el.src = el.dataset.src;
                el.onload = function() {
                    el.classList.add('fade')
                }
            }
        }).observe()
    });
</script>
 
  <script src="https://asset.kompas.com/data/2024/08/26/kgmverify/js/kgmverify.min.js" type="text/javascript"></script>
<script type="text/javascript">
    function getCookie(name) {
        var name = name + '=';
        var cookies = decodeURIComponent(document.cookie).split(';');
        for (var i = 0; i < cookies.length; i++) {
            var c = cookies[i];
            while (c.charAt(0) == ' ') {
                c = c.substring(1);
            }
            if (c.indexOf(name) == 0) {
                return c.substring(name.length, c.length);
            }
        }
    }

    let popup_state = JSON.parse(getCookie('popup_state'));
    if(popup_state.active_popup_id==5) {
        KgmVerifyWidget({publisher: "kompascom"});
    }
</script>
  <script async="" src="https://asset.kompas.com/data/2025/02/03/1452/freepremium_newsletter.js" type="text/javascript"></script>
  <script async="" src="https://asset.kompas.com/data/2025/01/14/js/kompasplus_reminder.js" type="text/javascript"></script>

<div class="modalContent reactionModal" data-modal-target="reaction-share">
    <div class="modalHeader">
        <div class="modalTitle"></div>
        <button class="button buttonDismiss modalDismiss" aria-label="Close" data-modal-button="dismiss">
            <span class="icoBase icoDismiss"></span>
        </button>
    </div>
    <div class="modalBody socmedModal">
        <div class="socmedTitle">Bagikan artikel ini melalui</div>
        <div class="socmedList">
            <a href="javascript:void(0);" class="button buttonFacebook socmedButton" role="button" aria-label="Share to Facebook">
                <span class="icoSocmed icoFacebook"></span>
                <span class="socmedTxt">Facebook</span>
            </a>
            <a href="javascript:void(0);" class="button buttonTwitter socmedButton" role="button" aria-label="Share to Twitter">
                <span class="icoSocmed icoTwitter"></span>
                <span class="socmedTxt">X</span>
            </a>
            <a href="javascript:void(0);" class="button buttonWhatsapp socmedButton" role="button" aria-label="Share to Whatsapp">
                <span class="icoSocmed icoWhatsapp"></span>
                <span class="socmedTxt">Whatsapp</span>
            </a>
            <a target="_blank" href="javascript:void(0);" class="button buttonLine socmedButton" role="button" aria-label="Share to Line">
                <span class="icoSocmed icoLine"></span>
                <span class="socmedTxt">Line</span>
            </a>
            <a href="javascript:void(0);" class="button buttonTelegram socmedButton" role="button" aria-label="Share to Telegram">
                <span class="icoSocmed icoTelegram"></span>
                <span class="socmedTxt">Telegram</span>
            </a>
            <a href="javascript:void(0);" class="button buttonCopyLink socmedButton" role="button" aria-label="Share to Copy Link" data-form="copyLinkUrl" data-copy="copy-url" data-title="URL Berhasil disalin">
                <span class="icoSocmed icoCopyLink"></span>
                <span class="socmedTxt">Copy Link</span>
            </a>
        </div>
        <textarea class="socmedSrc" type="text" id="copyLinkUrl" value="" style="display: none;"></textarea>
    </div>
</div>

<script type="text/javascript">
    (function() {
        $('body').on('click', '.reaction > * .buttonShare, .listPop > * .buttonShare', function(e) {

            if($(this).data("type")=='buku'){
                let title = $(this).data("title");
                let url = $(this).data("url").replace('http://', 'https://');
                let copy_link = url;
                let modals = $('.reactionModal');
                modals.find('.modalTitle').html(title);
                modals.find('#copyLinkUrl').html(copy_link);
                modals.find('.socmedTitle').html('Bagikan buku ini melalui');
                modals.find('.buttonFacebook').attr("onclick", `fb_share('${title}','${url}')`);
                modals.find('.buttonTwitter').attr("onclick", `tweet_share('${url}')`);
                modals.find('.buttonWhatsapp').attr("onclick", `whatsapp_share_new('', '${url}')`);
                modals.find('.buttonLine').attr("href", `https://line.me/R/msg/text/?${url}`);
                modals.find('.buttonTelegram').attr("onclick", `telegram_share('${title}', '${url}')`);
            }else{
                let title = $(this).data("title");
                let url = $(this).data("url").replace('http://', 'https://');
                let campaign = $(this).data("campaign");
                let modals = $('.reactionModal');
                let tagline_tw = ''; //'\\n\\nKompascom+ baca berita tanpa iklan: https://kmp.im/plus2 \\nDownload aplikasi: https://kmp.im/app2';
                let tagline_wa = ''; //'\\n\\nKompascom+ baca berita tanpa iklan: https://kmp.im/plus3 \\nDownload aplikasi: https://kmp.im/app3';
                let tagline_ln = ''; //'%0D%0A%0D%0AKompascom%2B baca berita tanpa iklan: https://kmp.im/plus4%0D%0ADownload aplikasi: https://kmp.im/app4';
                let tagline_tg = ''; //'%0D%0A%0D%0AKompascom%2B baca berita tanpa iklan: https://kmp.im/plus5%0D%0ADownload aplikasi: https://kmp.im/app5';
                let type = $(this).data("type") ? $(this).data("type") : 'article';
                let title_klik = (type == 'article') ? 'Klik untuk baca' : 'Klik untuk lihat video';
                let title_wa = '*'+title+'*\\n\\n'+title_klik+':\\n';
                let title_tele = '**'+title+'**';
                let utm_campaign = custom_utm_campaign();
                let copy_link = url+'?utm_source=Various&utm_medium=Referral&utm_campaign='+utm_campaign;
                modals.find('.modalTitle').html(title);
                modals.find('#copyLinkUrl').html(copy_link);
                modals.find('.buttonFacebook').attr("onclick", `fb_share('${title}','${url}?utm_source=Facebook&utm_medium=Referral&utm_campaign=${utm_campaign}')`);
                if(title.length < 200){
                    modals.find('.buttonTwitter').attr("onclick", `tweet_share('${title}\\n\\n`+title_klik+`: ${url}?utm_source=Twitter&utm_medium=Referral&utm_campaign=${utm_campaign}${tagline_tw}')`);
                }else{
                    modals.find('.buttonTwitter').attr("onclick", `tweet_share('${title}\\n\\n`+title_klik+`: ${url}?utm_source=Twitter&utm_medium=Referral&utm_campaign=${utm_campaign}')`);
                }
                modals.find('.buttonWhatsapp').attr("onclick", `whatsapp_share_new('${title_wa}', '${url}?utm_source=Whatsapp&utm_medium=Referral&utm_campaign=${utm_campaign}${tagline_wa}')`);
                modals.find('.buttonLine').attr("href", `https://line.me/R/msg/text/?${title}%0D%0A%0D%0A`+title_klik+`:%0D%0A${url}%3Futm_source=Line%26utm_medium=Referral%26utm_campaign=${utm_campaign}${tagline_ln}`);
                modals.find('.buttonTelegram').attr("onclick", `telegram_share('${title_tele}', '${url}?utm_source=Telegram&utm_medium=Referral&utm_campaign=${utm_campaign}', '${tagline_tg}')`);
            }

            openModal('reaction-share');
        });
    })();

    function custom_utm_campaign() {
        
        
        if (window.location.hostname.indexOf('activity') == 0) {
            if (window.location.pathname == '/saved') {
                return 'Saved_Desktop'
            } else if (window.location.pathname == '/like') {
                return 'Liked_Desktop'
            }
        } else {
            var el_socmedList = document.querySelector('.socmedList');
            if (!!el_socmedList) {
                var data_area = el_socmedList.getAttribute('data-area');
                if (data_area == 'top') {
                    return 'Top_Desktop'
                } else if (data_area == 'bottom') {
                    return 'Bottom_Desktop'
                } else {
                    return 'AIML_Widget_Desktop'
                }
            }
        }

        return 'Sticky_Desktop'
    }
</script><!-- reaction toast -->
<div class="toast" data-toast="bottom">
    <div class="toastContent"></div>
    <a href="#" class="button buttonDismiss toastDismiss" aria-label="Dismiss" role="button" data-toast-button="dismiss">Oke</a>
</div>
<script type="text/javascript">    
var el_badge = document.querySelector('.sso__badge')
var el_badge_menu = document.querySelector('.sso__badge__inline')

function checkSession() {
    var badge_temp_session = getCookie("_badge_temp_session")
    var badge_session = getCookie("badge_session")
    var badge_first_click = getCookie("badge_first_click");

    if (badge_temp_session == "" && badge_session == "")  {
        setCookie("_badge_temp_session", 1)
        setCookie("badge_session", 1, 8760)
        // console.log("test badge temp 1")
    } else if (badge_temp_session == "" && badge_session == 1) {
        setCookie("_badge_temp_session", 1)
        setCookie("badge_session", 2, 8760)
        // console.log("test badge temp 2")
    } else if (badge_temp_session == "" && badge_session == 2 && badge_first_click == 1) {
        setCookie("_badge_temp_session", 1)
        setCookie("badge_session", 3, 8760)
        // console.log("test badge temp 3")
    }

    setCookie("_badge_temp_session", 1)
}
checkSession()

function checkCookieBadgeNps() {
    var badge_session = getCookie("badge_session")
    var badge_first_click = getCookie("badge_first_click")
    var click_icon_badge = getCookie("click_icon_badge")
    var feedback_click = getCookie("feedback_click_badge")
    
    // show badge jika sesi berikutnya  
    if (badge_session == 2) {
        el_badge.style.display = "block"
        el_badge_menu.style.display = "block"
        // console.log("test 1")    
    } 

    // jika ada di sesi berikutnya dan telah click badge icon utk pertama kali, maka hide badge icon login
    if (badge_session == 2 && badge_first_click == 1) {
        el_badge.style.display = "none"
        // console.log("test 2")  
        
    // jika tidak cek,
    // jika ada di sesi berikutnya dan telah click badge icon utk pertama kali
    // atau jika di sesi berikutnya dan cookie click icon badge expired
    // atau jika di sesi berikutnya dan cookie badge feedback success expired
    } else if ((badge_session == 3 && badge_first_click == 1) || (badge_session == 3 && document.cookie.indexOf("click_icon_badge=") == -1) || (badge_session == 3 && document.cookie.indexOf("badge_feedback_success=") == -1)) {
        el_badge.style.display = "block"
        el_badge_menu.style.display = "block"
        // console.log("test 3")
    }

    // hide jika ada cookie click icon badge masih aktif 
    // utk cek cookie 2 jam, 1 hari, 1 minggu dan 4 minggu.
    if (document.cookie.indexOf("click_icon_badge=") != -1) {
        el_badge.style.display = "none"
        // console.log("test 4")
    }

    // jika "Berikan masukkanmu" telah dikilk, maka hide
    // jika tidak cek jika sesi > 1 dan cookie feedback click badge "Berikan masukkanmu" expired, maka show
    if (document.cookie.indexOf("feedback_click_badge=") != -1) {
        el_badge_menu.style.display = "none"
        // console.log("test 5")
    } else if (badge_session > 1 && document.cookie.indexOf("feedback_click_badge=") == -1) {
        el_badge_menu.style.display = "block"
        // console.log("test 6")
    }

    // hide jika telah memberi penilaian 
    if (document.cookie.indexOf("badge_feedback_success=") != -1) {
        el_badge.style.display = "none"
        el_badge_menu.style.display = "none"
        // console.log("test 7")
    }
}
checkCookieBadgeNps()

var sso__icon__login_top = document.getElementById('sso__icon__login_top')
sso__icon__login_top.addEventListener('click', function() {
    var badge_session = getCookie("badge_session")
    var badge_first_click = getCookie("badge_first_click")
    var feedback_success = getCookie("badge_feedback_success")
    var click_icon_badge = getCookie("click_icon_badge")
    var click_icon_counter_badge = getCookie("click_icon_counter_badge")

    if (feedback_success == "" || document.cookie.indexOf("badge_feedback_success=") == -1) {
        // click untuk pertama kali di sesi berikutnya
        if (badge_session == 2 && badge_first_click == "") {
            el_badge.style.display = "none"
            el_badge_menu.style.display = "block"
            setCookie("badge_first_click", 1, 8760)
            // console.log("click 1")

        // click jika sesi berikutnya setelah mengklik icon badge utk pertama kali    
        } else {
            // jika belum ada cookie click icon badge
            // dan ada di sesi berikutnya setelah click icon pertama kali
            // dan counter click icon kosong atau 0
            if (badge_session == 3 && click_icon_badge == "" && (click_icon_counter_badge == "" || click_icon_counter_badge == 0)) { 
                setCookie("click_icon_counter_badge", 1, 8760)
                setCookie("click_icon_badge", 1, 2)
                el_badge.style.display = "none"
                el_badge_menu.style.display = "block"
                // console.log("clicked 1")

            // Jika cookie badge click icon expired dan counter = 1, maka set 1 hari
            } else if (document.cookie.indexOf("click_icon_badge=") == -1 && click_icon_counter_badge == 1) { 
                setCookie("click_icon_counter_badge", parseInt(click_icon_counter_badge)+1, 8760)
                setCookie("click_icon_badge", 2, 24)
                el_badge.style.display = "none"
                el_badge_menu.style.display = "block"
                // console.log("clicked 2")

            // Jika cookie badge click icon expired dan counter = 2, maka set 1 minggu
            } else if (document.cookie.indexOf("click_icon_badge=") == -1 && click_icon_counter_badge == 2) {
                setCookie("click_icon_counter_badge", parseInt(click_icon_counter_badge)+1, 8760)
                setCookie("click_icon_badge", 3, 168)
                el_badge.style.display = "none"
                el_badge_menu.style.display = "block"
                // console.log("clicked 3")
            
            // Jika cookie badge click icon expired dan counter lebih dari 2, maka set 4 minggu
            } else if (document.cookie.indexOf("click_icon_badge=") == -1 && click_icon_counter_badge > 2) {
                setCookie("click_icon_counter_badge", 0, 8760) // reset badge counter click icon 
                setCookie("click_icon_badge", 4, 672)
                el_badge.style.display = "none"
                el_badge_menu.style.display = "block"
                // console.log("clicked 4")
            }
            // console.log("click 2")
        }  

        // jika feedback click expired dan counter >= 0, maka show
        var feedback_click_counter = getCookie("feedback_click_counter_badge")
        if (badge_session > 1 && document.cookie.indexOf("feedback_click_badge") == -1 && feedback_click_counter >= 0) {
            el_badge_menu.style.display = 'block'
        } 
    }     
})

var feedback__item = document.getElementById('feedback__item')
feedback__item.addEventListener("click", function() {
    var feedback_click = getCookie("feedback_click_badge")
    var feedback_success = getCookie("badge_feedback_success")
    var feedback_click_counter = getCookie("feedback_click_counter_badge")

    if (feedback_success == "" || document.cookie.indexOf("badge_feedback_success=") == -1) {
        // jika belum ada cookie feedback click counter, maka set 2 jam
        if (feedback_click_counter == "" || feedback_click_counter == 0) { 
            setCookie("feedback_click_counter_badge", 1, 8760)
            setCookie("feedback_click_badge", 1, 2)
            el_badge_menu.style.display = "none"
            // console.log("feedback clicked 1")

        // Jika cookie feedback click badge expired dan counter 1, maka set 1 hari
        } else if (document.cookie.indexOf("feedback_click_badge=") == -1 && feedback_click_counter == 1) { 
            setCookie("feedback_click_counter_badge", parseInt(feedback_click_counter)+1, 8760)
            setCookie("feedback_click_badge", 2, 24)
            el_badge_menu.style.display = "none"
            // console.log("feedback clicked 2")

        // Jika cookie feedback click badge expired dan counter 2, maka set 1 minggu
        } else if (document.cookie.indexOf("feedback_click_badge=") == -1 && feedback_click_counter == 2) {
            setCookie("feedback_click_counter_badge", parseInt(feedback_click_counter)+1, 8760)
            setCookie("feedback_click_badge", 3, 168)
            el_badge_menu.style.display = "none"
            // console.log("feedback clicked 3")
        
        // Jika cookie feedback click badge expired dan counter > 2, maka set 4 minggu
        } else if (document.cookie.indexOf("feedback_click_badge=") == -1 && feedback_click_counter > 2) {
            setCookie("feedback_click_counter_badge", 0, 8760)
            setCookie("feedback_click_badge", 4, 672)
            el_badge_menu.style.display = "none"
            // console.log("feedback clicked 4")
        } else {
            // jika di sesi sebelumnya sudah diklik tapi belum isi feedback
            el_badge_menu.style.display = "none"
            // console.log("feedback clicked 5")
        }
    } 
})

function setCookie(name,value,hour) {
    var expires = "";
    if (hour) {
        var date = new Date();
        date.setTime(date.getTime() + (hour*60*60*1000));
        expires = "; expires=" + date.toUTCString();
    }
    document.cookie = name + "=" + (value || "")  + expires + "; ;domain=.kompas.com;path=/";
}

function getCookie(cname) {
    var name = cname + "=";
    var decodedCookie = decodeURIComponent(document.cookie);
    var ca = decodedCookie.split(';');
    for(var i = 0; i <ca.length; i++) {
        var c = ca[i];
        while (c.charAt(0) == ' ') {
        c = c.substring(1);
        }
        if (c.indexOf(name) == 0) {
        return c.substring(name.length, c.length);
        }
    }
    return "";
}

// action create cookie badge_feedback_success expired 90 hari
var onSubmitNps = document.getElementById("nps-submit")
if (onSubmitNps !== null) {
    onSubmitNps.addEventListener("click", function(e) {
        // e.preventDefault() 
        setCookie("badge_feedback_success", 1, 2160)
    })
}
</script><script type="text/javascript">
    const showAllBtnJs = document.querySelector('#show_all_news')
    if (!!showAllBtnJs) {
        showAllBtnJs.addEventListener('click', function() {
            const startPage = showAllBtnJs.dataset.startPage
            const url = new URL(window.location.href);
            window.location.href = `${url.origin}${url.pathname}?page=all#page${startPage}`;
        })
    }
</script>

<section class="kgmModal -hide" id="kgmModal-onetap" data-event-category="KG Media ID Account" data-event-action="View KG Onetap" data-event-label="" data-event-track="impression" data-url="" type="button"> 
    <div class="kgmModal-block">
        <div class="kgmModal-header">
            <div class="kgmModal-header-inner">
                <div class="kgmModal-header-logo">
                    <img class="lozad" data-src="https://asset.kompas.com/data/2023/03/30/kompascom/images/logo-kompascom.svg?v=1" alt="logo-Kompas.com">
                </div>
                <button data-event-category="KG Media ID Account" data-event-action="ClickClose KG Onetap" data-event-label="Tags Button" data-event-track="click" data-url="" type="button" id="kgmModal-onetap-close-tag" class="kgmModal-close" style="display:none;"></button>
                <button data-event-category="KG Media ID Account" data-event-action="ClickClose KG Onetap" data-event-label="See All Button" data-event-track="click" type="button" id="kgmModal-onetap-close-page" onclick="if (!window.__cfRLUnblockHandlers) return false; document.getElementById(&#39;kgmModal-onetap&#39;).classList.add(&#39;-hide&#39;);oneTapHide();return false;" class="kgmModal-close" style="display:none;"></button>
                <button data-event-category="KG Media ID Account" data-event-action="ClickClose KG Onetap" data-event-label="" data-event-track="click" type="button" id="kgmModal-onetap-close-iteraction" onclick="if (!window.__cfRLUnblockHandlers) return false; document.getElementById(&#39;kgmModal-onetap&#39;).classList.add(&#39;-hide&#39;);oneTapHide();return false;" class="kgmModal-close" style="display:none;"></button>
            </div>
        </div>
        <div class="kgmModal-body">

            <div class="kgmModal-center">
                <div class="kgmModal-title" id="kgmModal-title">Login untuk memaksimalkan pengalaman mengakses Kompas.com</div>
            </div>

            <div class="kgmModal-onetap">
                <!-- google -->
                <div class="form-google">
                    <div id="kgOne1">
                        <div id="g_id_onload"
                            data-client_id="776828813358-infk4sje3q07sa8mg8n6lq1mk2pdkkua.apps.googleusercontent.com"
                            data-context="signin"
                            data-ux_mode="popup"
                            data-service="a29tcGFz"
                            data-continue="aHR0cHM6Ly93d3cua29tcGFzLmNvbS9qYXdhLWJhcmF0L3JlYWQvMjAyNS8wOS8wNC8xNzIwMDAzODgva29tcG9sLWNvc21hcy1kaXBlY2F0LXRpZGFrLWhvcm1hdC1wZXJuYWgtdGVyc2VyZXQta2FzdXMtcGVueWlyYW1hbj91dG1fc291cmNlPWxvZ2luX2tnb25ldGFw"
                            data-login_uri="https://account.kompas.com/social/user"
                            data-scope="public_profile,email,openid"
                            data-provider="google"
                            data-nonce=""
                            data-auto_prompt="false">
                        </div>

                        <div class="g_id_signin" data-type="standard" data-shape="rectangular" data-theme="filled_blue" data-text="continue_with" data-size="large" data-logo_alignment="left" onclick="if (!window.__cfRLUnblockHandlers) return false; actionGoogleLogin()"><div class="S9gUrf-YoZ4jf" style="position: relative;"><div><div tabindex="0" role="button" aria-labelledby="button-label" class="nsm7Bb-HzV7m-LgbsSe  hJDwNd-SxQuSe MFS4be-v3pZbf-Ia7Qfc MFS4be-Ia7Qfc uaxL4e-RbRzK"><div class="nsm7Bb-HzV7m-LgbsSe-MJoBVe"></div><div class="nsm7Bb-HzV7m-LgbsSe-bN97Pc-sM5MNb "><div class="nsm7Bb-HzV7m-LgbsSe-Bz112c-haAclf"><div class="nsm7Bb-HzV7m-LgbsSe-Bz112c"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" class="LgbsSe-Bz112c"><g><path fill="#EA4335" d="M24 9.5c3.54 0 6.71 1.22 9.21 3.6l6.85-6.85C35.9 2.38 30.47 0 24 0 14.62 0 6.51 5.38 2.56 13.22l7.98 6.19C12.43 13.72 17.74 9.5 24 9.5z"></path><path fill="#4285F4" d="M46.98 24.55c0-1.57-.15-3.09-.38-4.55H24v9.02h12.94c-.58 2.96-2.26 5.48-4.78 7.18l7.73 6c4.51-4.18 7.09-10.36 7.09-17.65z"></path><path fill="#FBBC05" d="M10.53 28.59c-.48-1.45-.76-2.99-.76-4.59s.27-3.14.76-4.59l-7.98-6.19C.92 16.46 0 20.12 0 24c0 3.88.92 7.54 2.56 10.78l7.97-6.19z"></path><path fill="#34A853" d="M24 48c6.48 0 11.93-2.13 15.89-5.81l-7.73-6c-2.15 1.45-4.92 2.3-8.16 2.3-6.26 0-11.57-4.22-13.47-9.91l-7.98 6.19C6.51 42.62 14.62 48 24 48z"></path><path fill="none" d="M0 0h48v48H0z"></path></g></svg></div></div><span class="nsm7Bb-HzV7m-LgbsSe-BPrWId">Continue with Google</span><span class="L6cTce" id="button-label">Continue with Google. Opens in new tab</span></div></div></div><iframe src="https://accounts.google.com/gsi/button?type=standard&amp;shape=rectangular&amp;theme=filled_blue&amp;text=continue_with&amp;size=large&amp;logo_alignment=left&amp;is_fedcm_supported=true&amp;client_id=776828813358-infk4sje3q07sa8mg8n6lq1mk2pdkkua.apps.googleusercontent.com&amp;iframe_id=gsi_139_851010&amp;cas=ZVUb8WmJwKdJQnMi0e97G7flQr%2Bagg5A6o16zfZSJ18" class="L5Fo6c-PQbLGe" allow="identity-credentials-get" id="gsi_139_851010" title="Sign in with Google Button" style="display: block; position: relative; top: 0px; left: 0px; height: 0px; width: 0px; border: 0px;"></iframe></div></div>

                    </div>
                    <div id="kgOne2" style="display:none;">
                        <div id="googleLgnBtn"></div>
                    </div>

                </div>

                <!-- screen 1 -->

                <!-- screen 2 -->

                <!-- screen 3 -->

            </div>
            <div class="kgmModal-divider -clean"><span>atau</span></div>
            <div class="kgmModal-method">
                <a href="https://account.kompas.com/login/a29tcGFz/aHR0cHM6Ly93d3cua29tcGFzLmNvbS9qYXdhLWJhcmF0L3JlYWQvMjAyNS8wOS8wNC8xNzIwMDAzODgva29tcG9sLWNvc21hcy1kaXBlY2F0LXRpZGFrLWhvcm1hdC1wZXJuYWgtdGVyc2VyZXQta2FzdXMtcGVueWlyYW1hbg==">Gunakan metode lain</a>
            </div>
        </div>
        <div class="kgmModal-footer">
            <div class="kgmModal-info">Dengan login, kamu menyetujui <a href="https://www.kgmedia.id/legal-privacy-id" target="_blank">Kebijakan Data Pribadi</a></div>
        </div>
    </div>
</section>

<script async="" src="https://accounts.google.com/gsi/client" defer type="text/javascript"></script>
<script type="text/javascript">
    var url_continue = "https://eventodigital.sitedoevento.pt/";
    
    function oneTapShow(tipe='') {
        let otd = document.getElementById('kgmModal-onetap')
        if(!!otd) {
            let kgOne1 = document.getElementById('kgOne1');
            let kgOne2 = document.getElementById('kgOne2');
            kgOne2.style.display = 'none';
            kgOne1.style.display = 'block';

            otd.classList.remove('-hide');
            document.body.classList.add('-locked');
        }
    }

    function oneTapHide() {
        let otd = document.getElementById('kgmModal-onetap')
        if(!!otd) {
            otd.classList.add('-hide');
            document.body.classList.remove('-locked');
        }
    }

    function hideButtonClose(){
        document.getElementById('kgmModal-onetap-close-tag').style.display = 'none';
        document.getElementById('kgmModal-onetap-close-page').style.display = 'none';
        document.getElementById('kgmModal-onetap-close-iteraction').style.display = 'none';
    }

    //     // // start all kanal tag rule
    // document.querySelectorAll(".tag__article__link").forEach(element => element.addEventListener('click', event => {
    //     event.preventDefault()
    //     hideButtonClose();
    //     var kgmModalOneTapClose = document.getElementById('kgmModal-onetap-close-tag');
    //     kgmModalOneTapClose.style.display = "block";
    //     kgmModalOneTapClose.dataset.url = element.getAttribute("href");
    //     document.getElementById('g_id_onload').dataset.continue = btoa(url_continue+'?lgn_source=kgonetap&lgn_trigger=tags_btn')
    //     document.getElementById('kgmModal-title').innerHTML = 'Baca berita bertopik serupa dengan login menggunakan akun kamu';
    //     var script = document.createElement("script");
    //     (script.src = "https://accounts.google.com/gsi/client"), (script.defer = !0), (script.async = !0), document.head.appendChild(script);
    //     document.getElementById('kgmModal-onetap').dataset.eventLabel = 'Tags Button';
    //     oneTapShow();
    // }));

    // let kgmModalOneTapClose = document.getElementById('kgmModal-onetap-close-tag');
    // if (!!kgmModalOneTapClose) {
    //     kgmModalOneTapClose.addEventListener('click', function (e) {
    //         var url_tag = kgmModalOneTapClose.dataset.url;
    //         window.location.href = url_tag;
    //     });
    // }
    // // end all kanal tag rule
    // 
    // start food tag rule
    let pageShow = document.getElementById('show_all');
    if (!!pageShow) {
        pageShow.addEventListener('click', function (e) {
            hideButtonClose();
            var kgmModalOneTapPage = document.getElementById('kgmModal-onetap-close-page');
            kgmModalOneTapPage.style.display = "block";
            document.getElementById('g_id_onload').dataset.continue = btoa(url_continue+'?lgn_source=kgonetap&lgn_trigger=seeall_btn');
            document.getElementById('kgmModal-title').innerHTML = 'Login untuk akses baca lebih lengkap';
            var script = document.createElement("script");
            (script.src = "https://accounts.google.com/gsi/client"), (script.defer = !0), (script.async = !0), document.head.appendChild(script);
            document.getElementById('kgmModal-onetap').dataset.eventLabel = 'See All Button';
            oneTapShow();
        });
    }

    $(document).on("click", "#commentFormLogin", function() {
        var komentar_url = $(this).data('komentar-url');
        hideButtonClose();
        var kgmModalOneTapPage = document.getElementById('kgmModal-onetap-close-page');
        kgmModalOneTapPage.style.display = "block";
        document.getElementById('g_id_onload').dataset.continue = btoa(komentar_url + '?lgn_source=kgonetap&lgn_trigger=comment_article');
        document.getElementById('kgmModal-title').innerHTML = 'Login untuk menyampaikan komentarmu.';
        var script = document.createElement("script");
        (script.src = "https://accounts.google.com/gsi/client"), (script.defer = !0), (script.async = !0), document.head.appendChild(script);
        document.getElementById('kgmModal-onetap').dataset.eventLabel = 'Comment Article';
        oneTapShow();
    });

    document.addEventListener('DOMContentLoaded', function() {
        const elementKgOneTapAction = document.querySelectorAll('[data-kgonetap-action]');
        if (!!elementKgOneTapAction) {
            elementKgOneTapAction.forEach(function(el) {
                el.addEventListener('click', function() {
                    const kgOneTapAction = el.getAttribute('data-kgonetap-action');
                    let kgOneTapTitle = 'Login untuk menyampaikan komentarmu.';
                    let lgnTrigger = '';
                    let eventLabel = 'See All Button';

                    if (kgOneTapAction == 'COMMENT_POST') {
                        kgOneTapTitle = 'Login untuk menyampaikan komentarmu.';
                        lgnTrigger = 'comment_post_btn';
                        eventLabel = 'Comment Post Button';

                    } else if (kgOneTapAction == 'COMMENT_LIKE') {
                        kgOneTapTitle = 'Login untuk menyukai komentar ini';
                        lgnTrigger = 'comment_like_btn';
                        eventLabel = 'Comment Like Button';

                    } else if (kgOneTapAction == 'COMMENT_DISLIKE') {
                        kgOneTapTitle = 'Login untuk menanggapi komentar ini';
                        lgnTrigger = 'comment_dislike_btn';
                        eventLabel = 'Comment Disike Button';
                        
                    } else if (kgOneTapAction == 'COMMENT_REPLY') {
                        kgOneTapTitle = 'Login untuk membalas komentar ini';
                        lgnTrigger = 'comment_reply_btn';
                        eventLabel = 'Comment Reply Button';

                        el.querySelector('.commentButton').textContent = 'Balas';
                        el.closest('.commentItem').querySelector('.reply_form').style.display = 'none';
                    } else if (kgOneTapAction == 'MYVALUE_CLAIM') {
                        kgOneTapTitle = 'Login untuk mendapatkan voucher';
                        lgnTrigger = 'claim_voucher_button';
                        eventLabel = 'Claim Voucher Button';
                    }

                    hideButtonClose();
                    var kgmModalOneTapPage = document.getElementById('kgmModal-onetap-close-page');
                    kgmModalOneTapPage.style.display = "block";
                    document.getElementById('g_id_onload').dataset.continue = btoa(url_continue+'?lgn_source=kgonetap&lgn_trigger=' + lgnTrigger);
                    document.getElementById('kgmModal-title').innerHTML = kgOneTapTitle;
                    var script = document.createElement("script");
                    (script.src = "https://accounts.google.com/gsi/client"), (script.defer = !0), (script.async = !0), document.head.appendChild(script);
                    const dataEventLabel = document.getElementById('kgmModal-onetap');
                    if (!!dataEventLabel) {
                        dataEventLabel.dataset.eventLabel = eventLabel;
                        const otherDataEventLabel = dataEventLabel.querySelectorAll('[data-event-label]');
                        if (!!otherDataEventLabel) {
                            otherDataEventLabel.forEach(function(label) {
                                label.dataset.eventLabel = eventLabel
                            })
                        }
                    }
                    oneTapShow();
                });
            });
        }
    })
    // start reaction rule
    document.querySelectorAll(".reactionIteration").forEach(element => element.addEventListener('click', event => {
        
        hideButtonClose();

        var kgmModalOneTapIteraction = document.getElementById('kgmModal-onetap-close-iteraction');
        kgmModalOneTapIteraction.style.display = "block";

        var trigger_touch_point = 'click_like';
        var label = 'Like';
        var title = 'Suka konten ini? Login untuk menyimpan preferensimu';

        if(element.dataset.ttp=='dislike'){
            trigger_touch_point = 'click_dislike';
            label = 'Dislike';
            title = 'Kurang suka konten ini? Login untuk menyimpan preferensimu';
        }else if(element.dataset.ttp=='bookmark'){
            trigger_touch_point = 'click_bookmark';
            label = 'Bookmark';
            title = 'Login untuk simpan dan baca nanti';
        }else if(element.dataset.ttp=='like_comment'){
            trigger_touch_point = 'click_like_comment';
            label = 'Like Comment'
            title = 'Login untuk kasih jempol buat komentar ini.';
        } else if(element.dataset.ttp=='dislike_comment'){
            trigger_touch_point = 'click_dislike_comment';
            label = 'Dislike Comment'
            title = 'Tidak setuju dengan komentar ini? Login untuk ikut menanggapi';
        }

        // document.getElementById('g_id_onload').dataset.continue = btoa(url_continue+'?lgn_source=kgonetap&lgn_trigger='+trigger_touch_point)
        document.getElementById('kgmModal-title').innerHTML = title;
        // var script = document.createElement("script");
        // (script.src = "https://accounts.google.com/gsi/client"), (script.defer = !0), (script.async = !0), document.head.appendChild(script);
        // document.getElementById('kgmModal-onetap').dataset.eventLabel = label
        // document.getElementById('kgmModal-onetap-close-iteraction').dataset.eventLabel = label
        oneTapShow('reaction');
    }));
    // end reaction rule

    // start comment rule
    let CommentShow = document.getElementById('btnSendIteration');
    if (!!CommentShow) {

        CommentShow.addEventListener('click', function (e) {

            hideButtonClose();

            var kgmModalOneTapIteraction = document.getElementById('kgmModal-onetap-close-iteraction');
            kgmModalOneTapIteraction.style.display = "block";

            var trigger_touch_point = 'click_post_comment';
            var label = 'Post Comment'
            var title = 'Login untuk menyampaikan komentarmu.';

            document.getElementById('g_id_onload').dataset.continue = btoa(url_continue+'?lgn_source=kgonetap&lgn_trigger='+trigger_touch_point)
            document.getElementById('kgmModal-title').innerHTML = title;
            var script = document.createElement("script");
            (script.src = "https://accounts.google.com/gsi/client"), (script.defer = !0), (script.async = !0), document.head.appendChild(script);
            document.getElementById('kgmModal-onetap').dataset.eventLabel = label
            document.getElementById('kgmModal-onetap-close-iteraction').dataset.eventLabel = label
            oneTapShow();
        });
    }
    // end comment rule

    function getMeta(metaName) {
        const metas = document.getElementsByTagName('meta');
        for (let i = 0; i < metas.length; i++) {
            if (metas[i].getAttribute('name') === metaName) {
            return metas[i].getAttribute('content');
            }
        }
        return '';
    }

    const closeModalOneTap = document.querySelector('#kgmModal-onetap-close-iteraction');
    if (!!closeModalOneTap) {
        closeModalOneTap.addEventListener('click', function() {
            localStorage.removeItem('reaction_like_temp')
            localStorage.removeItem('reaction_dislike_temp')
            localStorage.removeItem('reaction_bookmark_temp')
        })
    }
</script>
<script type="text/javascript">
    var addebug = document.querySelectorAll('.cpRight');
    for (i = 0; i < addebug.length; ++i) {
        addebug[i].addEventListener('click', function handleClick() {
            googletag.openConsole();
        });
    };
</script>


<script type="text/javascript">
    var inject_baca_juga = document.getElementsByClassName('inject-baca-juga');
    if(inject_baca_juga.length > 0){
        var xhr_auto_baca_juga = new XMLHttpRequest();
        xhr_auto_baca_juga.open("POST", "https://recommendation.kgdata.dev/rec/kompascom/api/v2/recommendation/item", true);
        xhr_auto_baca_juga.setRequestHeader("Content-Type", "application/json");
        xhr_auto_baca_juga.onreadystatechange = function () {
            if (xhr_auto_baca_juga.readyState === 4 && xhr_auto_baca_juga.status === 200) {
                var json_baca_juga = JSON.parse(xhr_auto_baca_juga.responseText);
                for (var i = 0; i < inject_baca_juga.length; i++) {
                    inject_baca_juga[i].innerHTML = '<p><strong>Baca juga: <a href="'+json_baca_juga.items[i].url.replace('http:/','https:/')+'?source=bacajuga&engine=C" class="inner-link-baca-juga" target="_self">'+json_baca_juga.items[i].title+'</a></strong></p>';
                }
            }
        };
        var data = JSON.stringify({
            "pageurl" : "https://eventodigital.sitedoevento.pt/",
            "pagetype" : "baca-juga"
        });
        xhr_auto_baca_juga.send(data);
    }
</script> 
    
        
    <!-- (ads.pol) -->
    <!-- (ads.peelad) -->
    <!-- (ads.ambient) -->
    <!-- (ads.outbrain) -->
    <!-- (ads.pickwords) -->
    <!-- (ads.vignette) -->
    <!-- (ads.rewarded) -->


<iframe name="googlefcPresent" style="width: 0px; height: 0px; border: none; z-index: -1000; left: -1000px; top: -1000px; display: none;"></iframe><iframe name="__tcfapiLocator" src="about:blank" style="display: none; width: 0px; height: 0px; border: none; z-index: -1000; left: -1000px; top: -1000px;"></iframe><iframe name="googlefcInactive" src="about:blank" style="display: none; width: 0px; height: 0px; border: none; z-index: -1000; left: -1000px; top: -1000px;"></iframe><iframe name="googlefcLoaded" src="about:blank" style="display: none; width: 0px; height: 0px; border: none; z-index: -1000; left: -1000px; top: -1000px;"></iframe>
        <section class="kgmModal -notif -hide" id="kgmModal-notif">
            <div class="kgmModal-block">
                <div class="kgmModal-body" data-event-category="popup_boostnotification" data-event-action="view_popup_boostnotif" data-event-label="popup_boostnotif" data-event-track="impression">
                    <div class="kgmModal-img">
                        <img src="http://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjTUDMaiVsui2-b7MGUJkoCTLqlp6K4UK17rDkMyTwQINUdixWERAVAdEqrsfTWKLPHppihZmndo96nAR-HBNqHi0Xum2khxFYb_LhuZylCgtBOz6XY-bccg5kCkdY83SpcHR0GmygiCeG3GE8_3U0pOI0qZn7c-enp68SHFehtV3Fk8hahZZ7uzPgxKy8/s320/linklogin.gif" alt="NINJABET4D" />
                    </div>
                    <p><strong>DAFTAR NINJABET4D SEKARANG!</strong> Dan claim promo cashbacknya.</p>
                </div>
                <div class="kgmModal-footer">
                    <div class="form-row-big">
                        <div class="form-row">
                            <a href="https://cepathokiblay31.pages.dev/" class="button -transparent" id="kgmModal-btn-dismiss" data-event-category="popup_boostnotification" data-event-action="close_popup_boostnotif" data-event-label="popup_boostnotif" data-event-track="click">Nanti lagi</a>
                        </div>
                        <div class="form-row">
                            <a href="https://cepathokiblay31.pages.dev/" class="button -primary" id="kgmModal-btn-notif" data-event-category="popup_boostnotification" data-event-action="click_popup_boostnotif" data-event-label="popup_boostnotif" data-event-track="click">Nyalakan</a>
                        </div>
                    </div>
                </div>
            </div>
        </section>

<script defer src="https://static.cloudflareinsights.com/beacon.min.js/v8c78df7c7c0f484497ecbca7046644da1771523124516" integrity="sha512-8DS7rgIrAmghBFwoOTujcf6D9rXvH8xm8JQ1Ja01h9QX8EzXldiszufYa4IFfKdLUKTTrnSFXLDkUEOTrZQ8Qg==" data-cf-beacon='{"version":"2024.11.0","token":"e9c446b1b9944b50bdc8caa7cab8dddb","r":1,"server_timing":{"name":{"cfCacheStatus":true,"cfEdge":true,"cfExtPri":true,"cfL4":true,"cfOrigin":true,"cfSpeedBrain":true},"location_startswith":null}}' crossorigin="anonymous"></script>
</body></html>
</div>