Find this useful? Enter your email to receive occasional updates for securing PHP code.

PHP Decode

'Cgo8IWRvY3R5cGUgaHRtbD4KPGh0bWwgY2xhc3M9Im5vLWpzIiBsYW5nPSJlbiI+CjxoZWFkPgogIDxtZXRhIGNoY..

Decoded Output download

<?  '

<!doctype html>
<html class="no-js" lang="en">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width,initial-scale=1">
  <meta name="theme-color" content="">
  <link rel="amphtml" href="https://xn--12cl1fk1e.xyz/">
  <link rel="canonical" href="https://www.elaphye.com/">
  <link rel="icon" type="image/png" href="https://9b9d2f.myshopify.com/cdn/shop/files/icon-pikachu.png?crop=center&height=32&v=1702729896&width=32">
  <link rel="preconnect" href="https://fonts.shopifycdn.com" crossorigin>
  <title>Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin</title>
  <meta name="description" content="Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik">
  <meta property="og:site_name" content="Slot Gacor 2024">
  <meta property="og:url" content="https://www.elaphye.com/">
  <meta property="og:title" content="Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin">
  <meta property="og:type" content="product">
  <meta property="og:description" content="Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik">
  <meta property="og:image" content="//iili.io/JYh9IFp.jpg?v=1702729284">
  <meta property="og:image:secure_url" content="//iili.io/JYh9IFp.jpg?v=1702729284">
  <meta name="google-site-verification" content="FgI0nlShU1wrFaeGtkhdP9BMmZuDbz2waxQFpDS9hLA" />
  <meta property="og:image:width" content="713">
  <meta property="og:image:height" content="713">
  <meta property="og:price:amount" content="1.000,00">
  <meta property="og:price:currency" content="IDR">
  <meta name="twitter:card" content="summary_large_image">
  <meta name="twitter:title" content="Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin">
  <meta name="twitter:description" content="Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik">
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/constants.js?v=58251544750838685771702729579" defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/pubsub.js?v=158357773527763999511702729580" defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/global.js?v=113367515774722599301702729579" defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/animations.js?v=88693664871331136111702729578" defer="defer"></script>
  <script>window.performance && window.performance.mark && window.performance.mark('shopify.content_for_header.start');</script>
  <meta id="shopify-digital-wallet" name="shopify-digital-wallet" content="/62108369051/digital_wallets/dialog">
  <link rel="alternate" type="application/json+oembed" href="https://www.elaphye.com/.oembed">
  <script async="async" src="/checkouts/internal/preloads.js?permanent-domain=9b9d2f.myshopify.com&locale=en-ID"></script>
  <script id="shopify-features" type="application/json">{"accessToken":"fac82d16843ffc3f531984d15a54876d","betas":["rich-media-storefront-analytics"],"domain":"9b9d2f.myshopify.com","predictiveSearch":true,"shopId":62108369051,"smart_payment_buttons_url":"https:\/\/9b9d2f.myshopify.com\/cdn\/shopifycloud\/payment-sheet\/assets\/latest\/spb.en.js","dynamic_checkout_cart_url":"https:\/\/9b9d2f.myshopify.com\/cdn\/shopifycloud\/payment-sheet\/assets\/latest\/dynamic-checkout-cart.en.js","locale":"en","optimusEnabled":true,"optimusHidden":false,"betterDynamicCheckoutRecommendationVariant":"control","shopPromisePDPV3Enabled":true}</script>
  <script>var Shopify = Shopify || {};
    Shopify.shop = "9b9d2f.myshopify.com";
    Shopify.locale = "en";
    Shopify.currency = { "active": "IDR", "rate": "1.0" };
    Shopify.country = "ID";
    Shopify.theme = { "name": "Refresh", "id": 132929093787, "theme_store_id": 1567, "role": "main" };
    Shopify.theme.handle = "null";
    Shopify.theme.style = { "id": null, "handle": null };
    Shopify.cdnHost = "9b9d2f.myshopify.com/cdn";
    Shopify.routes = Shopify.routes || {};
    Shopify.routes.root = "/";</script>
  <script type="module">!function (o) { (o.Shopify = o.Shopify || {}).modules = !0 }(window);</script>
  <script>!function (o) { function n() { var o = []; function n() { o.push(Array.prototype.slice.apply(arguments)) } return n.q = o, n } var t = o.Shopify = o.Shopify || {}; t.loadFeatures = n(), t.autoloadFeatures = n() }(window);</script>
  <script
    id="__st">var __st = { "a": 62108369051, "offset": 32400, "reqid": "e2fd25e3-d8d6-43af-b08b-4f52009bfebf", "pageurl": "9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor", "u": "7101edf0f4c8", "p": "product", "rtyp": "product", "rid": 7814133612699 };</script>
  <script>window.ShopifyPaypalV4VisibilityTracking = true;</script>
  <script>!function (o) { o.addEventListener("DOMContentLoaded", function () { window.Shopify = window.Shopify || {}, window.Shopify.recaptchaV3 = window.Shopify.recaptchaV3 || { siteKey: "6LcCR2cUAAAAANS1Gpq_mDIJ2pQuJphsSQaUEuc9" }; var t = ['form[action*="/contact"] input[name="form_type"][value="contact"]', 'form[action*="/comments"] input[name="form_type"][value="new_comment"]', 'form[action*="/account"] input[name="form_type"][value="customer_login"]', 'form[action*="/account"] input[name="form_type"][value="recover_customer_password"]', 'form[action*="/account"] input[name="form_type"][value="create_customer"]', 'form[action*="/contact"] input[name="form_type"][value="customer"]'].join(","); function n(e) { e = e.target; null == e || null != (e = function e(t, n) { if (null == t.parentElement) return null; if ("FORM" != t.parentElement.tagName) return e(t.parentElement, n); for (var o = t.parentElement.action, r = 0; r < n.length; r++)if (-1 !== o.indexOf(n[r])) return t.parentElement; return null }(e, ["/contact", "/comments", "/account"])) && null != e.querySelector(t) && ((e = o.createElement("script")).setAttribute("src", "https://cdn.shopify.com/shopifycloud/storefront-recaptcha-v3/v0.6/index.js"), o.body.appendChild(e), o.removeEventListener("focus", n, !0), o.removeEventListener("change", n, !0), o.removeEventListener("click", n, !0)) } o.addEventListener("click", n, !0), o.addEventListener("change", n, !0), o.addEventListener("focus", n, !0) }) }(document);</script>
  <script integrity="sha256-h4dvokWvGcvRSqiG7VnGqoonxF0k3NeoHPLSMjUGIz4=" data-source-attribution="shopify.loadfeatures"
    defer="defer"
    src="https://9b9d2f.myshopify.com/cdn/shopifycloud/shopify/assets/storefront/load_feature-87876fa245af19cbd14aa886ed59c6aa8a27c45d24dcd7a81cf2d2323506233e.js"
    crossorigin="anonymous"></script>
  <script data-source-attribution="shopify.dynamic_checkout.dynamic.init">var Shopify = Shopify || {}; Shopify.PaymentButton = Shopify.PaymentButton || { isStorefrontPortableWallets: !0, init: function () { window.Shopify.PaymentButton.init = function () { }; var t = document.createElement("script"); t.src = "https://9b9d2f.myshopify.com/cdn/shopifycloud/portable-wallets/latest/portable-wallets.en.js", t.type = "module", document.head.appendChild(t) } };
  </script>
  <script>
    window.__shopify_portable_wallets_onerror__ = function (script) {
      if (script && script.src) console.error(`Failed to load portable wallets script ${script.src}`);
      var skeletons = document.querySelectorAll('dynamic-checkout > .shopify-payment-button__skeleton');
      for (var i = 0; i < skeletons.length; i++) skeletons[i].remove();
    }
  </script>

  <script type="module"
    src="https://9b9d2f.myshopify.com/cdn/shopifycloud/portable-wallets/latest/portable-wallets.en.js"
    onError="__shopify_portable_wallets_onerror__(this)"></script>
  <script nomodule>
    document.addEventListener("DOMContentLoaded", __shopify_portable_wallets_onerror__);
  </script>

  <script id="sections-script" data-sections="header" defer="defer"
    src="https://9b9d2f.myshopify.com/cdn/shop/t/3/compiled_assets/scripts.js?9"></script>
  <style id="shopify-dynamic-checkout">
    .shopify-payment-button__button--hidden {
      visibility: hidden;
    }

    .shopify-payment-button__button {
      border-radius: 4px;
      border: none;
      box-shadow: 0 0 0 0 transparent;
      color: white;
      cursor: pointer;
      display: block;
      font-size: 1em;
      font-weight: 500;
      line-height: 1;
      text-align: center;
      width: 100%;
      transition: background 0.2s ease-in-out;
    }

    .shopify-payment-button__button[disabled] {
      opacity: 0.6;
      cursor: default;
    }

    .shopify-payment-button__button--unbranded {
      background-color: #1990c6;
      padding: 1em 2em;
    }

    .shopify-payment-button__button--unbranded:hover:not([disabled]) {
      background-color: #136f99;
    }

    .shopify-payment-button__more-options {
      background: transparent;
      border: 0 none;
      cursor: pointer;
      display: block;
      font-size: 1em;
      margin-top: 1em;
      text-align: center;
      width: 100%;
    }

    .shopify-payment-button__more-options:hover:not([disabled]) {
      text-decoration: underline;
    }

    .shopify-payment-button__more-options[disabled] {
      opacity: 0.6;
      cursor: not-allowed;
    }

    .shopify-payment-button__button--branded {
      display: flex;
      flex-direction: column;
      min-height: 44px;
      position: relative;
      z-index: 1;
    }

    .shopify-payment-button__button--branded .shopify-cleanslate {
      flex: 1 !important;
      display: flex !important;
      flex-direction: column !important;
    }

    .shopify-payment-button__button.button.loading {
      position: relative;
      color: transparent;
    }

    .shopify-payment-button__button.button.loading>.loading-overlay__spinner {
      top: 50%;
      left: 50%;
      transform: translate(-50%, -50%);
      position: absolute;
      height: 100%;
      display: flex;
      align-items: center;
    }

    .shopify-payment-button__button.button.loading>.loading-overlay__spinner .spinner {
      width: -moz-fit-content;
      width: fit-content;
    }

    .button.loading>.loading-overlay__spinner .path {
      stroke: white;
    }

    .shopify-payment-button__button .loading-overlay__spinner {
      width: 1.8rem;
      display: inline-block;
    }

    .shopify-payment-button__button .spinner {
      animation: shopify-rotator 1.4s linear infinite;
    }

    @keyframes shopify-rotator {
      0% {
        transform: rotate(0deg);
      }

      100% {
        transform: rotate(270deg);
      }
    }

    .shopify-payment-button__button .path {
      stroke-dasharray: 280;
      stroke-dashoffset: 0;
      transform-origin: center;
      stroke: rgb(18, 18, 18);
      animation: shopify-dash 1.4s ease-in-out infinite;
    }

    @media screen and (forced-colors: active) {
      .shopify-payment-button__button .path {
        stroke: CanvasText;
      }
    }

    @keyframes shopify-dash {
      0% {
        stroke-dashoffset: 280;
      }

      50% {
        stroke-dashoffset: 75;
        transform: rotate(135deg);
      }

      100% {
        stroke-dashoffset: 280;
        transform: rotate(450deg);
      }
    }

    @keyframes walletsLoadingSkeleton {
      50% {
        opacity: 1;
      }

      75% {
        opacity: 0.5;
      }

      100% {
        opacity: 1;
      }
    }

    .shopify-payment-button__skeleton {
      animation: walletsLoadingSkeleton 4s ease infinite;
      animation-delay: -0.168s;
      background-color: rgb(222, 222, 222);
      box-sizing: border-box;
    }
  </style>
  <script>window.performance && window.performance.mark && window.performance.mark('shopify.content_for_header.end');</script>


  <style data-shopify>
    @font-face {
      font-family: Questrial;
      font-weight: 400;
      font-style: normal;
      font-display: swap;
      src: url("https://9b9d2f.myshopify.com/cdn/fonts/questrial/questrial_n4.0ba6d2b6094954bab23732c75d3ecb4c47a5869c.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=1c877dca0176e24fb693c96a00effe7dc86b84807825fc36c15d31a5855c198a") format("woff2"),
        url("https://9b9d2f.myshopify.com/cdn/fonts/questrial/questrial_n4.5abce10d8846bb9326c9741eaffed9667c847692.woff?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=ecfdd1a0d70b204b062041e26c0f12fa5afcc66d9f48e179cfa592d2eed57924") format("woff");
    }




    @font-face {
      font-family: Archivo;
      font-weight: 700;
      font-style: normal;
      font-display: swap;
      src: url("https://9b9d2f.myshopify.com/cdn/fonts/archivo/archivo_n7.6f363ab30b12ea00d5e6243ed0e977a11393a3ad.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=71d8d8d7b7f481d9861e01d35da303610c84b6b7bbd4dd1cf789f3baa8389481") format("woff2"),
        url("https://9b9d2f.myshopify.com/cdn/fonts/archivo/archivo_n7.846b40a5735bbd149ad44b083a19c3e5d88d8fab.woff?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=21ba532749a193088151c18f1519f61c74b4154bed66180bcb909122609b234b") format("woff");
    }



    :root,
    .color-background-1 {
      --color-background: 239, 240, 245;

      --gradient-background: #fff;




      --color-foreground: 14, 27, 77;
      --color-background-contrast: 161, 166, 196;
      --color-shadow: 14, 27, 77;
      --color-button: 71, 112, 219;
      --color-button-text: 239, 240, 245;
      --color-secondary-button: 239, 240, 245;
      --color-secondary-button-text: 14, 27, 77;
      --color-link: 14, 27, 77;
      --color-badge-foreground: 14, 27, 77;
      --color-badge-background: 239, 240, 245;
      --color-badge-border: 14, 27, 77;
      --payment-terms-background-color: rgb(239 240 245);
    }


    .color-background-2 {
      --color-background: 255, 255, 255;

      --gradient-background: #ffffff;




      --color-foreground: 14, 27, 77;
      --color-background-contrast: 191, 191, 191;
      --color-shadow: 14, 27, 77;
      --color-button: 14, 27, 77;
      --color-button-text: 255, 255, 255;
      --color-secondary-button: 255, 255, 255;
      --color-secondary-button-text: 14, 27, 77;
      --color-link: 14, 27, 77;
      --color-badge-foreground: 14, 27, 77;
      --color-badge-background: 255, 255, 255;
      --color-badge-border: 14, 27, 77;
      --payment-terms-background-color: rgb(255 255 255);
    }


    .color-inverse {
      --color-background: 14, 27, 77;

      --gradient-background: #ef22ff;




      --color-foreground: 255, 255, 255;
      --color-background-contrast: 18, 35, 99;
      --color-shadow: 14, 27, 77;
      --color-button: 255, 255, 255;
      --color-button-text: 14, 27, 77;
      --color-secondary-button: 14, 27, 77;
      --color-secondary-button-text: 255, 255, 255;
      --color-link: 255, 255, 255;
      --color-badge-foreground: 255, 255, 255;
      --color-badge-background: 14, 27, 77;
      --color-badge-border: 255, 255, 255;
      --payment-terms-background-color: rgb(14 27 77);
    }


    .color-accent-1 {
      --color-background: 71, 112, 219;

      --gradient-background: #4770db;




      --color-foreground: 255, 255, 255;
      --color-background-contrast: 27, 57, 136;
      --color-shadow: 14, 27, 77;
      --color-button: 255, 255, 255;
      --color-button-text: 71, 112, 219;
      --color-secondary-button: 71, 112, 219;
      --color-secondary-button-text: 255, 255, 255;
      --color-link: 255, 255, 255;
      --color-badge-foreground: 255, 255, 255;
      --color-badge-background: 71, 112, 219;
      --color-badge-border: 255, 255, 255;
      --payment-terms-background-color: rgb(71 112 219);
    }


    .color-accent-2 {
      --color-background: 227, 36, 2;

      --gradient-background: #e32402;




      --color-foreground: 255, 255, 255;
      --color-background-contrast: 101, 16, 1;
      --color-shadow: 14, 27, 77;
      --color-button: 255, 255, 255;
      --color-button-text: 227, 36, 2;
      --color-secondary-button: 227, 36, 2;
      --color-secondary-button-text: 255, 255, 255;
      --color-link: 255, 255, 255;
      --color-badge-foreground: 255, 255, 255;
      --color-badge-background: 227, 36, 2;
      --color-badge-border: 255, 255, 255;
      --payment-terms-background-color: rgb(227 36 2);
    }


    body,
    .color-background-1,
    .color-background-2,
    .color-inverse,
    .color-accent-1,
    .color-accent-2 {
      color: rgba(var(--color-foreground), 0.75);
      background-color: rgb(var(--color-background));
    }

    :root {
      --font-body-family: Questrial, sans-serif;
      --font-body-style: normal;
      --font-body-weight: 400;
      --font-body-weight-bold: 700;

      --font-heading-family: Archivo, serif;
      --font-heading-style: normal;
      --font-heading-weight: 700;

      --font-body-scale: 1.05;
      --font-heading-scale: 1.0476190476190477;

      --media-padding: px;
      --media-border-opacity: 0.1;
      --media-border-width: 0px;
      --media-radius: 20px;
      --media-shadow-opacity: 0.0;
      --media-shadow-horizontal-offset: 0px;
      --media-shadow-vertical-offset: 4px;
      --media-shadow-blur-radius: 5px;
      --media-shadow-visible: 0;

      --page-width: 120rem;
      --page-width-margin: 0rem;

      --product-card-image-padding: 1.6rem;
      --product-card-corner-radius: 1.8rem;
      --product-card-text-alignment: left;
      --product-card-border-width: 0.1rem;
      --product-card-border-opacity: 1.0;
      --product-card-shadow-opacity: 0.0;
      --product-card-shadow-visible: 0;
      --product-card-shadow-horizontal-offset: 0.0rem;
      --product-card-shadow-vertical-offset: 0.4rem;
      --product-card-shadow-blur-radius: 0.5rem;

      --collection-card-image-padding: 1.6rem;
      --collection-card-corner-radius: 1.8rem;
      --collection-card-text-alignment: left;
      --collection-card-border-width: 0.1rem;
      --collection-card-border-opacity: 1.0;
      --collection-card-shadow-opacity: 0.0;
      --collection-card-shadow-visible: 0;
      --collection-card-shadow-horizontal-offset: 0.0rem;
      --collection-card-shadow-vertical-offset: 0.4rem;
      --collection-card-shadow-blur-radius: 0.5rem;

      --blog-card-image-padding: 1.6rem;
      --blog-card-corner-radius: 1.8rem;
      --blog-card-text-alignment: left;
      --blog-card-border-width: 0.1rem;
      --blog-card-border-opacity: 1.0;
      --blog-card-shadow-opacity: 0.0;
      --blog-card-shadow-visible: 0;
      --blog-card-shadow-horizontal-offset: 0.0rem;
      --blog-card-shadow-vertical-offset: 0.4rem;
      --blog-card-shadow-blur-radius: 0.5rem;

      --badge-corner-radius: 0.0rem;

      --popup-border-width: 1px;
      --popup-border-opacity: 0.1;
      --popup-corner-radius: 18px;
      --popup-shadow-opacity: 0.0;
      --popup-shadow-horizontal-offset: 0px;
      --popup-shadow-vertical-offset: 4px;
      --popup-shadow-blur-radius: 5px;

      --drawer-border-width: 0px;
      --drawer-border-opacity: 0.1;
      --drawer-shadow-opacity: 0.0;
      --drawer-shadow-horizontal-offset: 0px;
      --drawer-shadow-vertical-offset: 4px;
      --drawer-shadow-blur-radius: 5px;

      --spacing-sections-desktop: 0px;
      --spacing-sections-mobile: 0px;

      --grid-desktop-vertical-spacing: 28px;
      --grid-desktop-horizontal-spacing: 28px;
      --grid-mobile-vertical-spacing: 14px;
      --grid-mobile-horizontal-spacing: 14px;

      --text-boxes-border-opacity: 0.1;
      --text-boxes-border-width: 0px;
      --text-boxes-radius: 20px;
      --text-boxes-shadow-opacity: 0.0;
      --text-boxes-shadow-visible: 0;
      --text-boxes-shadow-horizontal-offset: 0px;
      --text-boxes-shadow-vertical-offset: 4px;
      --text-boxes-shadow-blur-radius: 5px;

      --buttons-radius: 40px;
      --buttons-radius-outset: 41px;
      --buttons-border-width: 1px;
      --buttons-border-opacity: 1.0;
      --buttons-shadow-opacity: 0.0;
      --buttons-shadow-visible: 0;
      --buttons-shadow-horizontal-offset: 0px;
      --buttons-shadow-vertical-offset: 4px;
      --buttons-shadow-blur-radius: 5px;
      --buttons-border-offset: 0.3px;

      --inputs-radius: 26px;
      --inputs-border-width: 1px;
      --inputs-border-opacity: 0.55;
      --inputs-shadow-opacity: 0.0;
      --inputs-shadow-horizontal-offset: 0px;
      --inputs-margin-offset: 0px;
      --inputs-shadow-vertical-offset: 4px;
      --inputs-shadow-blur-radius: 5px;
      --inputs-radius-outset: 27px;

      --variant-pills-radius: 40px;
      --variant-pills-border-width: 1px;
      --variant-pills-border-opacity: 0.55;
      --variant-pills-shadow-opacity: 0.0;
      --variant-pills-shadow-horizontal-offset: 0px;
      --variant-pills-shadow-vertical-offset: 4px;
      --variant-pills-shadow-blur-radius: 5px;
    }

    *,
    *::before,
    *::after {
      box-sizing: inherit;
    }

    html {
      box-sizing: border-box;
      font-size: calc(var(--font-body-scale) * 62.5%);
      height: 100%;
    }

    body {
      display: grid;
      grid-template-rows: auto auto 1fr auto;
      grid-template-columns: 100%;
      min-height: 100%;
      margin: 0;
      font-size: 1.5rem;
      letter-spacing: 0.06rem;
      line-height: calc(1 + 0.8 / var(--font-body-scale));
      font-family: var(--font-body-family);
      font-style: var(--font-body-style);
      font-weight: var(--font-body-weight);
    }

    @media screen and (min-width: 750px) {
      body {
        font-size: 1.6rem;
      }
    }
  </style>

  <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/base.css?v=127867003511637661291702729578"
    rel="stylesheet" type="text/css" media="all" />
  <link rel="preload" as="font"
    href="https://9b9d2f.myshopify.com/cdn/fonts/questrial/questrial_n4.0ba6d2b6094954bab23732c75d3ecb4c47a5869c.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=1c877dca0176e24fb693c96a00effe7dc86b84807825fc36c15d31a5855c198a"
    type="font/woff2" crossorigin>
  <link rel="preload" as="font"
    href="https://9b9d2f.myshopify.com/cdn/fonts/archivo/archivo_n7.6f363ab30b12ea00d5e6243ed0e977a11393a3ad.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=71d8d8d7b7f481d9861e01d35da303610c84b6b7bbd4dd1cf789f3baa8389481"
    type="font/woff2" crossorigin>
  <link rel="stylesheet"
    href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-predictive-search.css?v=118923337488134913561702729579"
    media="print" onload="this.media='all'">
  <script>
    document.documentElement.className = document.documentElement.className.replace('no-js', 'js');
    if (Shopify.designMode) {
      document.documentElement.classList.add('shopify-design-mode');
    }
  </script>
  <link href="https://monorail-edge.shopifysvc.com" rel="dns-prefetch">
  <script>(function () { if ("sendBeacon" in navigator && "performance" in window) { var session_token = document.cookie.match(/_shopify_s=([^;]*)/); function handle_abandonment_event(e) { var entries = performance.getEntries().filter(function (entry) { return /monorail-edge.shopifysvc.com/.test(entry.name); }); if (!window.abandonment_tracked && entries.length === 0) { window.abandonment_tracked = true; var currentMs = Date.now(); var navigation_start = performance.timing.navigationStart; var payload = { shop_id: 62108369051, url: window.location.href, navigation_start, duration: currentMs - navigation_start, session_token: session_token && session_token.length === 2 ? session_token[1] : "", page_type: "product" }; window.navigator.sendBeacon("https://monorail-edge.shopifysvc.com/v1/produce", JSON.stringify({ schema_id: "online_store_buyer_site_abandonment/1.1", payload: payload, metadata: { event_created_at_ms: currentMs, event_sent_at_ms: currentMs } })); } } window.addEventListener('pagehide', handle_abandonment_event); } }());</script>
  <script
    id="web-pixels-manager-setup">(function e(e, n, a, t, o, r, i) { var s = null !== e, l = ("function" == typeof BigInt && BigInt.toString().indexOf("[native code]") ? "modern" : "legacy").substring(0, 1), c = t.substring(0, 1); if (s) { window.Shopify = window.Shopify || {}; var d = window.Shopify; d.analytics = d.analytics || {}; var u = d.analytics; u.replayQueue = [], u.publish = function (e, n, a) { u.replayQueue.push([e, n, a]) }; try { self.performance.mark("wpm:start") } catch (e) { } } var p, f, y, h, v, m, w, g, b, _ = [a, "/wpm", "/", c, r, l, ".js"].join(""); f = (p = { src: _, async: !0, onload: function () { if (e) { var a = window.webPixelsManager.init(e); null == n || n(a); var t = window.Shopify.analytics; t.replayQueue.forEach((function (e) { var n = e[0], t = e[1], o = e[2]; a.publishCustomEvent(n, t, o) })), t.replayQueue = [], t.publish = a.publishCustomEvent, t.visitor = a.visitor } }, onerror: function () { var n = (null == e ? void 0 : e.storefrontBaseUrl) ? e.storefrontBaseUrl.replace(/\/$/, "") : self.location.origin, a = "".concat(n, "/.well-known/shopify/monorail/unstable/produce_batch"), t = JSON.stringify({ metadata: { event_sent_at_ms: (new Date).getTime() }, events: [{ schema_id: "web_pixels_manager_load/2.0", payload: { version: o || "latest", page_url: self.location.href, status: "failed", error_msg: "".concat(_, " has failed to load") }, metadata: { event_created_at_ms: (new Date).getTime() } }] }); try { if (self.navigator.sendBeacon.bind(self.navigator)(a, t)) return !0 } catch (e) { } var r = new XMLHttpRequest; try { return r.open("POST", a, !0), r.setRequestHeader("Content-Type", "text/plain"), r.send(t), !0 } catch (e) { console && console.warn && console.warn("[Web Pixels Manager] Got an unhandled error while logging a load error.") } return !1 } }).src, y = p.async, h = void 0 === y || y, v = p.onload, m = p.onerror, w = document.createElement("script"), g = document.head, b = document.body, w.async = h, w.src = f, v && w.addEventListener("load", v), m && w.addEventListener("error", m), g ? g.appendChild(w) : b ? b.appendChild(w) : console.error("Did not find a head or body element to append the script") })({ shopId: 62108369051, storefrontBaseUrl: "https://9b9d2f.myshopify.com", cdnBaseUrl: "https://9b9d2f.myshopify.com/cdn", surface: "storefront-renderer", enabledBetaFlags: ["web_pixels_async_pixel_refactor", "web_pixels_manager_performance_improvement"], webPixelsConfigList: [{ "id": "shopify-app-pixel", "configuration": "{}", "eventPayloadVersion": "v1", "runtimeContext": "STRICT", "scriptVersion": "0570", "apiClientId": "shopify-pixel", "type": "APP" }, { "id": "shopify-custom-pixel", "eventPayloadVersion": "v1", "runtimeContext": "LAX", "scriptVersion": "0570", "apiClientId": "shopify-pixel", "type": "CUSTOM" }], initData: { "cart": null, "checkout": null, "customer": null, "productVariants": [{ "id": "43910119325851", "image": { "src": "\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/slotgacornih.jpg?v=1702729284" }, "price": { "amount": 0.0, "currencyCode": "IDR" }, "product": { "id": "7814133612699", "title": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "untranslatedTitle": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "url": "\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor", "vendor": "Slot Gacor 2024", "type": "" }, "sku": "", "title": "Default Title", "untranslatedTitle": "Default Title" }] }, }, function pageEvents(webPixelsManagerAPI) { webPixelsManagerAPI.publish("page_viewed"); webPixelsManagerAPI.publish("product_viewed", { "productVariant": { "id": "43910119325851", "image": { "src": "\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/slotgacornih.jpg?v=1702729284" }, "price": { "amount": 0.0, "currencyCode": "IDR" }, "product": { "id": "7814133612699", "title": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "untranslatedTitle": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "url": "\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor", "vendor": "Slot Gacor 2024", "type": "" }, "sku": "", "title": "Default Title", "untranslatedTitle": "Default Title" } }); }, "https://9b9d2f.myshopify.com/cdn", "browser", "0.0.411", "38cecb8bw83165fb4p6f715253m9cc56095", ["web_pixels_async_pixel_refactor", "web_pixels_manager_performance_improvement"]);</script>
  <script>window.ShopifyAnalytics = window.ShopifyAnalytics || {};
    window.ShopifyAnalytics.meta = window.ShopifyAnalytics.meta || {};
    window.ShopifyAnalytics.meta.currency = 'IDR';
    var meta = { "product": { "id": 7814133612699, "gid": "gid:\/\/shopify\/Product\/7814133612699", "vendor": "Slot Gacor 2024", "type": "", "variants": [{ "id": 43910119325851, "price": 0, "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "public_title": null, "sku": "" }] }, "page": { "pageType": "product", "resourceType": "product", "resourceId": 7814133612699 } };
    for (var attr in meta) {
      window.ShopifyAnalytics.meta[attr] = meta[attr];
    }</script>
  <script>window.ShopifyAnalytics.merchantGoogleAnalytics = function () {

    };
  </script>
  <script class="analytics">(function () {
      var customDocumentWrite = function (content) {
        var jquery = null;

        if (window.jQuery) {
          jquery = window.jQuery;
        } else if (window.Checkout && window.Checkout.$) {
          jquery = window.Checkout.$;
        }

        if (jquery) {
          jquery('body').append(content);
        }
      };

      var hasLoggedConversion = function (token) {
        if (token) {
          return document.cookie.indexOf('loggedConversion=' + token) !== -1;
        }
        return false;
      }

      var setCookieIfConversion = function (token) {
        if (token) {
          var twoMonthsFromNow = new Date(Date.now());
          twoMonthsFromNow.setMonth(twoMonthsFromNow.getMonth() + 2);

          document.cookie = 'loggedConversion=' + token + '; expires=' + twoMonthsFromNow;
        }
      }

      var trekkie = window.ShopifyAnalytics.lib = window.trekkie = window.trekkie || [];
      if (trekkie.integrations) {
        return;
      }
      trekkie.methods = [
        'identify',
        'page',
        'ready',
        'track',
        'trackForm',
        'trackLink'
      ];
      trekkie.factory = function (method) {
        return function () {
          var args = Array.prototype.slice.call(arguments);
          args.unshift(method);
          trekkie.push(args);
          return trekkie;
        };
      };
      for (var i = 0; i < trekkie.methods.length; i++) {
        var key = trekkie.methods[i];
        trekkie[key] = trekkie.factory(key);
      }
      trekkie.load = function (config) {
        trekkie.config = config || {};
        trekkie.config.initialDocumentCookie = document.cookie;
        var first = document.getElementsByTagName('script')[0];
        var script = document.createElement('script');
        script.type = 'text/javascript';
        script.onerror = function (e) {
          var scriptFallback = document.createElement('script');
          scriptFallback.type = 'text/javascript';
          scriptFallback.onerror = function (error) {
            var Monorail = {
              produce: function produce(monorailDomain, schemaId, payload) {
                var currentMs = new Date().getTime();
                var event = {
                  schema_id: schemaId,
                  payload: payload,
                  metadata: {
                    event_created_at_ms: currentMs,
                    event_sent_at_ms: currentMs
                  }
                };
                return Monorail.sendRequest("https://" + monorailDomain + "/v1/produce", JSON.stringify(event));
              },
              sendRequest: function sendRequest(endpointUrl, payload) {
                // Try the sendBeacon API
                if (window && window.navigator && typeof window.navigator.sendBeacon === 'function' && typeof window.Blob === 'function' && !Monorail.isIos12()) {
                  var blobData = new window.Blob([payload], {
                    type: 'text/plain'
                  });

                  if (window.navigator.sendBeacon(endpointUrl, blobData)) {
                    return true;
                  } // sendBeacon was not successful

                } // XHR beacon

                var xhr = new XMLHttpRequest();

                try {
                  xhr.open('POST', endpointUrl);
                  xhr.setRequestHeader('Content-Type', 'text/plain');
                  xhr.send(payload);
                } catch (e) {
                  console.log(e);
                }

                return false;
              },
              isIos12: function isIos12() {
                return window.navigator.userAgent.lastIndexOf('iPhone; CPU iPhone OS 12_') !== -1 || window.navigator.userAgent.lastIndexOf('iPad; CPU OS 12_') !== -1;
              }
            };
            Monorail.produce('monorail-edge.shopifysvc.com',
              'trekkie_storefront_load_errors/1.1',
              {
                shop_id: 62108369051,
                theme_id: 132929093787,
                app_name: "storefront",
                context_url: window.location.href,
                source_url: "https://9b9d2f.myshopify.com/cdn/s/trekkie.storefront.7a4225caf9379fe42103e492053220a7195df1ae.min.js"
              });

          };
          scriptFallback.async = true;
          scriptFallback.src = 'https://9b9d2f.myshopify.com/cdn/s/trekkie.storefront.7a4225caf9379fe42103e492053220a7195df1ae.min.js';
          first.parentNode.insertBefore(scriptFallback, first);
        };
        script.async = true;
        script.src = 'https://9b9d2f.myshopify.com/cdn/s/trekkie.storefront.7a4225caf9379fe42103e492053220a7195df1ae.min.js';
        first.parentNode.insertBefore(script, first);
      };
      trekkie.load(
        { "Trekkie": { "appName": "storefront", "development": false, "defaultAttributes": { "shopId": 62108369051, "isMerchantRequest": null, "themeId": 132929093787, "themeCityHash": "1037719678984080351", "contentLanguage": "en", "currency": "IDR" }, "isServerSideCookieWritingEnabled": true, "monorailRegion": "shop_domain" }, "Session Attribution": {}, "S2S": { "facebookCapiEnabled": false, "source": "trekkie-storefront-renderer" } }
      );

      var loaded = false;
      trekkie.ready(function () {
        if (loaded) return;
        loaded = true;

        window.ShopifyAnalytics.lib = window.trekkie;


        var originalDocumentWrite = document.write;
        document.write = customDocumentWrite;
        try { window.ShopifyAnalytics.merchantGoogleAnalytics.call(this); } catch (error) { };
        document.write = originalDocumentWrite;

        window.ShopifyAnalytics.lib.page(null, { "pageType": "product", "resourceType": "product", "resourceId": 7814133612699 });

        var match = window.location.pathname.match(/checkouts\/(.+)\/(thank_you|post_purchase)/)
        var token = match ? match[1] : undefined;
        if (!hasLoggedConversion(token)) {
          setCookieIfConversion(token);
          window.ShopifyAnalytics.lib.track("Viewed Product", { "currency": "IDR", "variantId": 43910119325851, "productId": 7814133612699, "productGid": "gid:\/\/shopify\/Product\/7814133612699", "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "price": "0.00", "sku": "", "brand": "Slot Gacor 2024", "variant": null, "category": "", "nonInteraction": true });
          window.ShopifyAnalytics.lib.track("monorail:\/\/trekkie_storefront_viewed_product\/1.1", { "currency": "IDR", "variantId": 43910119325851, "productId": 7814133612699, "productGid": "gid:\/\/shopify\/Product\/7814133612699", "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "price": "0.00", "sku": "", "brand": "Slot Gacor 2024", "variant": null, "category": "", "nonInteraction": true, "referer": "https:\/\/9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor" });
        }
      });


      var eventsListenerScript = document.createElement('script');
      eventsListenerScript.async = true;
      eventsListenerScript.src = "https://9b9d2f.myshopify.com/cdn/shopifycloud/shopify/assets/shop_events_listener-a7c63dba65ccddc484f77541dc8ca437e60e1e9e297fe1c3faebf6523a0ede9b.js";
      document.getElementsByTagName('head')[0].appendChild(eventsListenerScript);

    })();</script>
  <script class="boomerang">
    (function () {
      if (window.BOOMR && (window.BOOMR.version || window.BOOMR.snippetExecuted)) {
        return;
      }
      window.BOOMR = window.BOOMR || {};
      window.BOOMR.snippetStart = new Date().getTime();
      window.BOOMR.snippetExecuted = true;
      window.BOOMR.snippetVersion = 12;
      window.BOOMR.application = "storefront-renderer";
      window.BOOMR.themeName = "Refresh";
      window.BOOMR.themeVersion = "12.0.0";
      window.BOOMR.shopId = 62108369051;
      window.BOOMR.themeId = 132929093787;
      window.BOOMR.renderRegion = "gcp-us-central1";
      window.BOOMR.url =
        "https://9b9d2f.myshopify.com/cdn/shopifycloud/boomerang/shopify-boomerang-1.0.0.min.js";
      var where = document.currentScript || document.getElementsByTagName("script")[0];
      var parentNode = where.parentNode;
      var promoted = false;
      var LOADER_TIMEOUT = 3000;
      function promote() {
        if (promoted) {
          return;
        }
        var script = document.createElement("script");
        script.id = "boomr-scr-as";
        script.src = window.BOOMR.url;
        script.async = true;
        parentNode.appendChild(script);
        promoted = true;
      }
      function iframeLoader(wasFallback) {
        promoted = true;
        var dom, bootstrap, iframe, iframeStyle;
        var doc = document;
        var win = window;
        window.BOOMR.snippetMethod = wasFallback ? "if" : "i";
        bootstrap = function (parent, scriptId) {
          var script = doc.createElement("script");
          script.id = scriptId || "boomr-if-as";
          script.src = window.BOOMR.url;
          BOOMR_lstart = new Date().getTime();
          parent = parent || doc.body;
          parent.appendChild(script);
        };
        if (!window.addEventListener && window.attachEvent && navigator.userAgent.match(/MSIE [67]./)) {
          window.BOOMR.snippetMethod = "s";
          bootstrap(parentNode, "boomr-async");
          return;
        }
        iframe = document.createElement("IFRAME");
        iframe.src = "about:blank";
        iframe.title = "";
        iframe.role = "presentation";
        iframe.loading = "eager";
        iframeStyle = (iframe.frameElement || iframe).style;
        iframeStyle.width = 0;
        iframeStyle.height = 0;
        iframeStyle.border = 0;
        iframeStyle.display = "none";
        parentNode.appendChild(iframe);
        try {
          win = iframe.contentWindow;
          doc = win.document.open();
        } catch (e) {
          dom = document.domain;
          iframe.src = "javascript:var d=document.open();d.domain='" + dom + "';void(0);";
          win = iframe.contentWindow;
          doc = win.document.open();
        }
        if (dom) {
          doc._boomrl = function () {
            this.domain = dom;
            bootstrap();
          };
          doc.write("<body onload='document._boomrl();'>");
        } else {
          win._boomrl = function () {
            bootstrap();
          };
          if (win.addEventListener) {
            win.addEventListener("load", win._boomrl, false);
          } else if (win.attachEvent) {
            win.attachEvent("onload", win._boomrl);
          }
        }
        doc.close();
      }
      var link = document.createElement("link");
      if (link.relList &&
        typeof link.relList.supports === "function" &&
        link.relList.supports("preload") &&
        ("as" in link)) {
        window.BOOMR.snippetMethod = "p";
        link.href = window.BOOMR.url;
        link.rel = "preload";
        link.as = "script";
        link.addEventListener("load", promote);
        link.addEventListener("error", function () {
          iframeLoader(true);
        });
        setTimeout(function () {
          if (!promoted) {
            iframeLoader(true);
          }
        }, LOADER_TIMEOUT);
        BOOMR_lstart = new Date().getTime();
        parentNode.appendChild(link);
      } else {
        iframeLoader(false);
      }
      function boomerangSaveLoadTime(e) {
        window.BOOMR_onload = (e && e.timeStamp) || new Date().getTime();
      }
      if (window.addEventListener) {
        window.addEventListener("load", boomerangSaveLoadTime, false);
      } else if (window.attachEvent) {
        window.attachEvent("onload", boomerangSaveLoadTime);
      }
      if (document.addEventListener) {
        document.addEventListener("onBoomerangLoaded", function (e) {
          e.detail.BOOMR.init({
            ResourceTiming: {
              enabled: true,
              trackedResourceTypes: ["script", "img", "css"]
            },
          });
          e.detail.BOOMR.t_end = new Date().getTime();
        });
      } else if (document.attachEvent) {
        document.attachEvent("onpropertychange", function (e) {
          if (!e) e = event;
          if (e.propertyName === "onBoomerangLoaded") {
            e.detail.BOOMR.init({
              ResourceTiming: {
                enabled: true,
                trackedResourceTypes: ["script", "img", "css"]
              },
            });
            e.detail.BOOMR.t_end = new Date().getTime();
          }
        });
      }
    })();</script>
</head>

<body class="gradient">
  <a class="skip-to-content-link button visually-hidden" href="#MainContent">
    Skip to content
  </a>

  <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/quantity-popover.css?v=153075665213740339621702729580"
    rel="stylesheet" type="text/css" media="all" />
  <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-card.css?v=47260860684073105921702729578"
    rel="stylesheet" type="text/css" media="all" />

  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/cart.js?v=56933888273975671431702729578"
    defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/quantity-popover.js?v=19455713230017000861702729580"
    defer="defer"></script>

  <style>
    .drawer {
      visibility: hidden;
    }
  </style>

  <cart-drawer class="drawer is-empty">
    <div id="CartDrawer" class="cart-drawer">
      <div id="CartDrawer-Overlay" class="cart-drawer__overlay"></div>
      <div class="drawer__inner gradient color-background-1" role="dialog" aria-modal="true" aria-label="Your cart"
        tabindex="-1">
        <div class="drawer__inner-empty">
          <div class="cart-drawer__warnings center">
            <div class="cart-drawer__empty-content">
              <h2 class="cart__empty-text">Your cart is empty</h2>
              <button class="drawer__close" type="button" onclick="this.closest('cart-drawer').close()"
                aria-label="Close">
                <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" class="icon icon-close"
                  fill="none" viewBox="0 0 18 17">
                  <path
                    d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                    fill="currentColor">
                </svg>

              </button>
              <a href="/collections/all" class="button">
                Continue shopping
              </a>
            </div>
          </div>
        </div>
        <div class="drawer__header">
          <h2 class="drawer__heading">Your cart</h2>
          <button class="drawer__close" type="button" onclick="this.closest('cart-drawer').close()" aria-label="Close">
            <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" class="icon icon-close"
              fill="none" viewBox="0 0 18 17">
              <path
                d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                fill="currentColor">
            </svg>

          </button>
        </div>
        <cart-drawer-items class=" is-empty">
          <form action="/cart" id="CartDrawer-Form" class="cart__contents cart-drawer__form" method="post">
            <div id="CartDrawer-CartItems" class="drawer__contents js-contents">
              <p id="CartDrawer-LiveRegionText" class="visually-hidden" role="status"></p>
              <p id="CartDrawer-LineItemStatus" class="visually-hidden" aria-hidden="true" role="status">
                Loading...
              </p>
            </div>
            <div id="CartDrawer-CartErrors" role="alert"></div>
          </form>
        </cart-drawer-items>
        <div class="drawer__footer"><!-- Start blocks -->
          <!-- Subtotals -->

          <div class="cart-drawer__footer">
            <div></div>

            <div class="totals" role="status">
              <h2 class="totals__total">Estimated total</h2>
              <p class="totals__total-value">Rp 1.000,00 IDR</p>
            </div>

            <small class="tax-note caption-large rte">Taxes, discounts and shipping calculated at checkout
            </small>
          </div>

          <!-- CTAs -->

          <div class="cart__ctas">
            <noscript>
              <button type="submit" class="cart__update-button button button--secondary" form="CartDrawer-Form">
                Update
              </button>
            </noscript>

            <button type="submit" id="CartDrawer-Checkout" class="cart__checkout-button button" name="checkout"
              form="CartDrawer-Form" disabled>
              Check out
            </button>
          </div>
        </div>
      </div>
    </div>
  </cart-drawer>

  <script>
    document.addEventListener('DOMContentLoaded', function () {
      function isIE() {
        const ua = window.navigator.userAgent;
        const msie = ua.indexOf('MSIE ');
        const trident = ua.indexOf('Trident/');

        return msie > 0 || trident > 0;
      }

      if (!isIE()) return;
      const cartSubmitInput = document.createElement('input');
      cartSubmitInput.setAttribute('name', 'checkout');
      cartSubmitInput.setAttribute('type', 'hidden');
      document.querySelector('#cart').appendChild(cartSubmitInput);
      document.querySelector('#checkout').addEventListener('click', function (event) {
        document.querySelector('#cart').submit();
      });
    });
  </script>
  <!-- BEGIN sections: header-group -->
  <div id="shopify-section-sections--16262122963099__header"
    class="shopify-section shopify-section-group-header-group section-header">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-menu.css?v=151968516119678728991702729578"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-search.css?v=165164710990765432851702729579"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-menu-drawer.css?v=31331429079022630271702729579"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-notification.css?v=54116361853792938221702729578"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-items.css?v=145340746371385151771702729578"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-price.css?v=70172745017360139101702729579"
      media="print" onload="this.media='all'">
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-drawer.css?v=11376100058507027511702729578"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart.css?v=181291337967238571831702729578"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-totals.css?v=15906652033866631521702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-price.css?v=70172745017360139101702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-discounts.css?v=152760482443307489271702729578"
      rel="stylesheet" type="text/css" media="all" />
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-menu.css?v=151968516119678728991702729578"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-search.css?v=165164710990765432851702729579"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-menu-drawer.css?v=31331429079022630271702729579"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-notification.css?v=54116361853792938221702729578"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-items.css?v=145340746371385151771702729578"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>

    <style>
      header-drawer {
        justify-self: start;
        margin-left: -1.2rem;
      }

      @media screen and (min-width: 990px) {
        header-drawer {
          display: none;
        }
      }

      .menu-drawer-container {
        display: flex;
      }

      .list-menu {
        list-style: none;
        padding: 0;
        margin: 0;
      }

      .list-menu--inline {
        display: inline-flex;
        flex-wrap: wrap;
      }

      summary.list-menu__item {
        padding-right: 2.7rem;
      }

      .list-menu__item {
        display: flex;
        align-items: center;
        line-height: calc(1 + 0.3 / var(--font-body-scale));
      }

      .list-menu__item--link {
        text-decoration: none;
        padding-bottom: 1rem;
        padding-top: 1rem;
        line-height: calc(1 + 0.8 / var(--font-body-scale));
      }

      @media screen and (min-width: 750px) {
        .list-menu__item--link {
          padding-bottom: 0.5rem;
          padding-top: 0.5rem;
        }
      }
    </style>
    <style data-shopify>
      .header {
        padding: 10px 3rem 10px 3rem;
      }

      .section-header {
        position: sticky;
        /* This is for fixing a Safari z-index issue. PR #2147 */
        margin-bottom: 0px;
      }

      @media screen and (min-width: 750px) {
        .section-header {
          margin-bottom: 0px;
        }
      }

      @media screen and (min-width: 990px) {
        .header {
          padding-top: 20px;
          padding-bottom: 20px;
        }
      }
    </style>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/details-disclosure.js?v=13653116266235556501702729579"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/details-modal.js?v=25581673532751508451702729579"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/cart-notification.js?v=133508293167896966491702729578"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/search-form.js?v=133129549252120666541702729580"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/cart-drawer.js?v=105077087914686398511702729578"
      defer="defer"></script><svg xmlns="http://www.w3.org/2000/svg" class="hidden">
      <symbol id="icon-search" viewbox="0 0 18 19" fill="none">
        <path fill-rule="evenodd" clip-rule="evenodd"
          d="M11.03 11.68A5.784 5.784 0 112.85 3.5a5.784 5.784 0 018.18 8.18zm.26 1.12a6.78 6.78 0 11.72-.7l5.4 5.4a.5.5 0 11-.71.7l-5.41-5.4z"
          fill="currentColor" />
      </symbol>

      <symbol id="icon-reset" class="icon icon-close" fill="none" viewBox="0 0 18 18" stroke="currentColor">
        <circle r="8.5" cy="9" cx="9" stroke-opacity="0.2" />
        <path d="M6.82972 6.82915L1.17193 1.17097" stroke-linecap="round" stroke-linejoin="round"
          transform="translate(5 5)" />
        <path d="M1.22896 6.88502L6.77288 1.11523" stroke-linecap="round" stroke-linejoin="round"
          transform="translate(5 5)" />
      </symbol>

      <symbol id="icon-close" class="icon icon-close" fill="none" viewBox="0 0 18 17">
        <path
          d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
          fill="currentColor">
      </symbol>
    </svg>
    <div class="header-wrapper color-inverse gradient">
      <header class="header header--top-center header--mobile-center page-width">

        <details-modal class="header__search">
          <details>
            <summary class="header__icon header__icon--search header__icon--summary link focus-inset modal__toggle"
              aria-haspopup="dialog" aria-label="Search">
              <span>
                <svg class="modal__toggle-open icon icon-search" aria-hidden="true" focusable="false">
                  <use href="#icon-search">
                </svg>
                <svg class="modal__toggle-close icon icon-close" aria-hidden="true" focusable="false">
                  <use href="#icon-close">
                </svg>
              </span>
            </summary>
            <div class="search-modal modal__content gradient" role="dialog" aria-modal="true" aria-label="Search">
              <div class="modal-overlay"></div>
              <div class="search-modal__content search-modal__content-bottom" tabindex="-1"><predictive-search
                  class="search-modal__form" data-loading-text="Loading...">
                  <form action="/search" method="get" role="search" class="search search-modal__form">
                    <div class="field">
                      <input class="search__input field__input" id="Search-In-Modal-1" type="search" name="q" value=""
                        placeholder="Search" role="combobox" aria-expanded="false" aria-owns="predictive-search-results"
                        aria-controls="predictive-search-results" aria-haspopup="listbox" aria-autocomplete="list"
                        autocorrect="off" autocomplete="off" autocapitalize="off" spellcheck="false">
                      <label class="field__label" for="Search-In-Modal-1">Search</label>
                      <input type="hidden" name="options[prefix]" value="last">
                      <button type="reset" class="reset__button field__button hidden" aria-label="Clear search term">
                        <svg class="icon icon-close" aria-hidden="true" focusable="false">
                          <use xlink:href="#icon-reset">
                        </svg>
                      </button>
                      <button class="search__button field__button" aria-label="Search">
                        <svg class="icon icon-search" aria-hidden="true" focusable="false">
                          <use href="#icon-search">
                        </svg>
                      </button>
                    </div>
                    <div class="predictive-search predictive-search--header" tabindex="-1" data-predictive-search>

                      <link
                        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                        rel="stylesheet" type="text/css" media="all" />

                      <div class="predictive-search__loading-state">
                        <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                          xmlns="http://www.w3.org/2000/svg">
                          <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                        </svg>
                      </div>
                    </div>

                    <span class="predictive-search-status visually-hidden" role="status" aria-hidden="true"></span>
                  </form>
                </predictive-search><button type="button"
                  class="search-modal__close-button modal__close-button link link--text focus-inset" aria-label="Close">
                  <svg class="icon icon-close" aria-hidden="true" focusable="false">
                    <use href="#icon-close">
                  </svg>
                </button>
              </div>
            </div>
          </details>
        </details-modal>
        <a href="https://www.elaphye.com/" class="header__heading-link link link--text focus-inset">
          <div class="header__heading-logo-wrapper">

            <img src="//img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=600"
              alt="Slot Gacor 2024"
              srcset="//img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=300 300w, //img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=450 450w, //img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=600 600w"
              width="300" height="58.30078125" loading="eager" class="header__heading-logo motion-reduce"
              sizes="(max-width: 600px) 50vw, 300px">
          </div>
        </a>
        <div class="header__icons header__icons--localization header-localization">
          <div class="desktop-localization-wrapper">
          </div>


          <details-modal class="header__search">
            <details>
              <summary class="header__icon header__icon--search header__icon--summary link focus-inset modal__toggle"
                aria-haspopup="dialog" aria-label="Search">
                <span>
                  <svg class="modal__toggle-open icon icon-search" aria-hidden="true" focusable="false">
                    <use href="#icon-search">
                  </svg>
                  <svg class="modal__toggle-close icon icon-close" aria-hidden="true" focusable="false">
                    <use href="#icon-close">
                  </svg>
                </span>
              </summary>
              <div class="search-modal modal__content gradient" role="dialog" aria-modal="true" aria-label="Search">
                <div class="modal-overlay"></div>
                <div class="search-modal__content search-modal__content-bottom" tabindex="-1"><predictive-search
                    class="search-modal__form" data-loading-text="Loading...">
                    <form action="/search" method="get" role="search" class="search search-modal__form">
                      <div class="field">
                        <input class="search__input field__input" id="Search-In-Modal" type="search" name="q" value=""
                          placeholder="Search" role="combobox" aria-expanded="false"
                          aria-owns="predictive-search-results" aria-controls="predictive-search-results"
                          aria-haspopup="listbox" aria-autocomplete="list" autocorrect="off" autocomplete="off"
                          autocapitalize="off" spellcheck="false">
                        <label class="field__label" for="Search-In-Modal">Search</label>
                        <input type="hidden" name="options[prefix]" value="last">
                        <button type="reset" class="reset__button field__button hidden" aria-label="Clear search term">
                          <svg class="icon icon-close" aria-hidden="true" focusable="false">
                            <use xlink:href="#icon-reset">
                          </svg>
                        </button>
                        <button class="search__button field__button" aria-label="Search">
                          <svg class="icon icon-search" aria-hidden="true" focusable="false">
                            <use href="#icon-search">
                          </svg>
                        </button>
                      </div>
                      <div class="predictive-search predictive-search--header" tabindex="-1" data-predictive-search>

                        <link
                          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                          rel="stylesheet" type="text/css" media="all" />

                        <div class="predictive-search__loading-state">
                          <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                            xmlns="http://www.w3.org/2000/svg">
                            <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                          </svg>
                        </div>
                      </div>

                      <span class="predictive-search-status visually-hidden" role="status" aria-hidden="true"></span>
                    </form>
                  </predictive-search><button type="button"
                    class="search-modal__close-button modal__close-button link link--text focus-inset"
                    aria-label="Close">
                    <svg class="icon icon-close" aria-hidden="true" focusable="false">
                      <use href="#icon-close">
                    </svg>
                  </button>
                </div>
              </div>
            </details>
          </details-modal>

          <a href="https://www.elaphye.com/" class="header__icon header__icon--cart link focus-inset" id="cart-icon-bubble"><svg
              class="icon icon-cart-empty" aria-hidden="true" focusable="false" xmlns="http://www.w3.org/2000/svg"
              viewBox="0 0 40 40" fill="none">
              <path
                d="m15.75 11.8h-3.16l-.77 11.6a5 5 0 0 0 4.99 5.34h7.38a5 5 0 0 0 4.99-5.33l-.78-11.61zm0 1h-2.22l-.71 10.67a4 4 0 0 0 3.99 4.27h7.38a4 4 0 0 0 4-4.27l-.72-10.67h-2.22v.63a4.75 4.75 0 1 1 -9.5 0zm8.5 0h-7.5v.63a3.75 3.75 0 1 0 7.5 0z"
                fill="currentColor" fill-rule="evenodd" />
            </svg>
            <span class="visually-hidden">Cart</span></a>
        </div>
      </header>
    </div>

    <script type="application/ld+json">
  {
    "@context": "http://schema.org",
    "@type": "Organization",
    "name": "Slot Gacor 2024",
    
      "logo": "https:\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/SLOTGACORR.png?v=1702729701\u0026width=500",
    
    "sameAs": [
      "",
      "",
      "",
      "",
      "",
      "",
      "",
      "",
      ""
    ],
    "url": "https:\/\/9b9d2f.myshopify.com"
  }
</script>
  </div>
  <!-- END sections: header-group -->

  <main id="MainContent" class="content-for-layout focus-none" role="main" tabindex="-1">
    <section id="shopify-section-template--16262122635419__main" class="shopify-section section">
      <section id="MainProduct-template--16262122635419__main"
        class="section-template--16262122635419__main-padding gradient color-background-1"
        data-section="template--16262122635419__main">
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/section-main-product.css?v=141059467971401676601702729580"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-accordion.css?v=180964204318874863811702729578"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-price.css?v=70172745017360139101702729579"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-slider.css?v=142503135496229589681702729579"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841702729579"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-deferred-media.css?v=14096082462203297471702729578"
          rel="stylesheet" type="text/css" media="all" />
        <style data-shopify>
          .section-template--16262122635419__main-padding {
            padding-top: 45px;
            padding-bottom: 45px;
          }

          @media screen and (min-width: 750px) {
            .section-template--16262122635419__main-padding {
              padding-top: 60px;
              padding-bottom: 60px;
            }
          }
        </style>
        <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/product-info.js?v=81873523020508815201702729580"
          defer="defer"></script>
        <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/product-form.js?v=133081758708377679181702729580"
          defer="defer"></script>

        <div class="page-width">
          <div
            class="product product--small product--left product--thumbnail_slider product--mobile-hide grid grid--1-col grid--2-col-tablet">
            <div class="grid__item product__media-wrapper">

              <media-gallery id="MediaGallery-template--16262122635419__main" role="region"
                class="product__column-sticky" aria-label="Gallery Viewer" data-desktop-layout="thumbnail_slider">
                <div id="GalleryStatus-template--16262122635419__main" class="visually-hidden" role="status"></div>
                <slider-component id="GalleryViewer-template--16262122635419__main" class="slider-mobile-gutter"><a
                    class="skip-to-content-link button visually-hidden quick-add-hidden"
                    href="#ProductInfo-template--16262122635419__main">
                    Skip to product information
                  </a>
                  <ul id="Slider-Gallery-template--16262122635419__main"
                    class="product__media-list contains-media grid grid--peek list-unstyled slider slider--mobile"
                    role="list">
                    <li id="Slide-template--16262122635419__main-28590940422299"
                      class="product__media-item grid__item slider__slide is-active scroll-trigger animate--fade-in"
                      data-media-id="template--16262122635419__main-28590940422299">

                      <div
                        class="product-media-container media-type-image media-fit-contain global-media-settings gradient constrain-height"
                        style="--ratio: 1.0; --preview-ratio: 1.0;">
                        <noscript>
                          <div class="product__media media">
                            <img
                              src="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946"
                              alt=""
                              srcset="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=246 246w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=493 493w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=600 600w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=713 713w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=823 823w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=990 990w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1100 1100w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1206 1206w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1346 1346w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1426 1426w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1646 1646w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946 1946w"
                              width="1946" height="1946"
                              sizes="(min-width: 1200px) 495px, (min-width: 990px) calc(45.0vw - 10rem), (min-width: 750px) calc((100vw - 11.5rem) / 2), calc(100vw / 1 - 4rem)">
                          </div>
                        </noscript>

                        <modal-opener class="product__modal-opener product__modal-opener--image no-js-hidden"
                          data-modal="#ProductModal-template--16262122635419__main">
                          <span class="product__media-icon motion-reduce quick-add-hidden product__media-icon--lightbox"
                            aria-hidden="true"><svg aria-hidden="true" focusable="false" class="icon icon-plus"
                              width="19" height="19" viewBox="0 0 19 19" fill="none" xmlns="http://www.w3.org/2000/svg">
                              <path fill-rule="evenodd" clip-rule="evenodd"
                                d="M4.66724 7.93978C4.66655 7.66364 4.88984 7.43922 5.16598 7.43853L10.6996 7.42464C10.9758 7.42395 11.2002 7.64724 11.2009 7.92339C11.2016 8.19953 10.9783 8.42395 10.7021 8.42464L5.16849 8.43852C4.89235 8.43922 4.66793 8.21592 4.66724 7.93978Z"
                                fill="currentColor" />
                              <path fill-rule="evenodd" clip-rule="evenodd"
                                d="M7.92576 4.66463C8.2019 4.66394 8.42632 4.88723 8.42702 5.16337L8.4409 10.697C8.44159 10.9732 8.2183 11.1976 7.94215 11.1983C7.66601 11.199 7.44159 10.9757 7.4409 10.6995L7.42702 5.16588C7.42633 4.88974 7.64962 4.66532 7.92576 4.66463Z"
                                fill="currentColor" />
                              <path fill-rule="evenodd" clip-rule="evenodd"
                                d="M12.8324 3.03011C10.1255 0.323296 5.73693 0.323296 3.03011 3.03011C0.323296 5.73693 0.323296 10.1256 3.03011 12.8324C5.73693 15.5392 10.1255 15.5392 12.8324 12.8324C15.5392 10.1256 15.5392 5.73693 12.8324 3.03011ZM2.32301 2.32301C5.42035 -0.774336 10.4421 -0.774336 13.5395 2.32301C16.6101 5.39361 16.6366 10.3556 13.619 13.4588L18.2473 18.0871C18.4426 18.2824 18.4426 18.599 18.2473 18.7943C18.0521 18.9895 17.7355 18.9895 17.5402 18.7943L12.8778 14.1318C9.76383 16.6223 5.20839 16.4249 2.32301 13.5395C-0.774335 10.4421 -0.774335 5.42035 2.32301 2.32301Z"
                                fill="currentColor" />
                            </svg>
                          </span>

                          <link
                            href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                            rel="stylesheet" type="text/css" media="all" />

                          <div class="loading__spinner hidden">
                            <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                              xmlns="http://www.w3.org/2000/svg">
                              <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                            </svg>
                          </div>
                          <div class="product__media media media--transparent">
                            <img
                              src="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946"
                              alt=""
                              srcset="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=246 246w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=493 493w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=600 600w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=713 713w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=823 823w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=990 990w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1100 1100w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1206 1206w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1346 1346w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1426 1426w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1646 1646w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946 1946w"
                              width="1946" height="1946" class="image-magnify-lightbox"
                              sizes="(min-width: 1200px) 495px, (min-width: 990px) calc(45.0vw - 10rem), (min-width: 750px) calc((100vw - 11.5rem) / 2), calc(100vw / 1 - 4rem)">
                          </div>
                          <button class="product__media-toggle quick-add-hidden product__media-zoom-lightbox"
                            type="button" aria-haspopup="dialog" data-media-id="28590940422299">
                            <span class="visually-hidden">
                              Open media 1 in modal
                            </span>
                          </button>
                        </modal-opener>
                      </div>

                    </li>
                  </ul>
                  <div class="slider-buttons no-js-hidden quick-add-hidden small-hide">
                    <button type="button" class="slider-button slider-button--prev" name="previous"
                      aria-label="Slide left">
                      <svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
                          fill="currentColor">
                      </svg>

                    </button>
                    <div class="slider-counter caption">
                      <span class="slider-counter--current">1</span>
                      <span aria-hidden="true"> / </span>
                      <span class="visually-hidden">of</span>
                      <span class="slider-counter--total">1</span>
                    </div>
                    <button type="button" class="slider-button slider-button--next" name="next"
                      aria-label="Slide right">
                      <svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
                          fill="currentColor">
                      </svg>

                    </button>
                  </div>
                </slider-component>
              </media-gallery>

            </div>
            <div class="product__info-wrapper grid__item scroll-trigger animate--slide-in">
              <product-info id="ProductInfo-template--16262122635419__main"
                data-section="template--16262122635419__main"
                data-url="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor"
                class="product__info-container product__column-sticky">
                <p class="product__text inline-richtext">LINK SLOT MAXWIN</p>
                <div class="product__title">
                  <h1>Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin</h1>
                  <a href="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor" class="product__title">
                    <h2 class="h1">
                      Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin
                    </h2>
                  </a>
                </div>
                <div class="no-js-hidden" id="price-template--16262122635419__main" role="status">
                  <div class="
    price price--large price--sold-out price--show-badge">
                    <div class="price__container">
                      <div class="price__regular"><span class="visually-hidden visually-hidden--inline">Regular
                          price</span>
                        <span class="price-item price-item--regular">
                          Rp 1.000,00
                        </span>
                      </div>
                      <div class="price__sale">
                        <span class="visually-hidden visually-hidden--inline">Regular price</span>
                        <span>
                          <s class="price-item price-item--regular">



                          </s>
                        </span><span class="visually-hidden visually-hidden--inline">Sale price</span>
                        <span class="price-item price-item--sale price-item--last">
                          Rp 1.000,00
                        </span>
                      </div>
                      <small class="unit-price caption hidden">
                        <span class="visually-hidden">Unit price</span>
                        <span class="price-item price-item--last">
                          <span></span>
                          <span aria-hidden="true">/</span>
                          <span class="visually-hidden">&nbsp;per&nbsp;</span>
                          <span>
                          </span>
                        </span>
                      </small>
                    </div><span class="badge price__badge-sale color-accent-1">
                      Sale
                    </span>
                    <br>
                    <span class="badge price__badge-sold-out color-background-1">
                      Slot Maxwin Bre
                    </span>
                  </div>
                </div>
                <div class="product__tax caption rte"></div>
                <div>
                  <form method="post" action="/cart/add" id="product-form-installment-template--16262122635419__main"
                    accept-charset="UTF-8" class="installment caption-large" enctype="multipart/form-data"><input
                      type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8"
                      value="✓" /><input type="hidden" name="id" value="43910119325851">

                    <input type="hidden" name="product-id" value="7814133612699" />
                  </form>
                </div>
                <noscript class="product-form__noscript-wrapper-template--16262122635419__main">
                  <div class="product-form__input hidden">
                    <label class="form__label" for="Variants-template--16262122635419__main">Product variants</label>
                    <div class="select">
                      <select name="id" id="Variants-template--16262122635419__main" class="select__select"
                        form="product-form-template--16262122635419__main">
                        <option selected="selected" disabled value="43910119325851">Default Title - Rp 1.000,00 - Sold out
                        </option>
                      </select>
                      <svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
                          fill="currentColor">
                      </svg>

                    </div>
                  </div>
                </noscript>

                <div id="Quantity-Form-template--16262122635419__main"
                  class="product-form__input product-form__quantity">



                  <label class="quantity__label form__label" for="Quantity-template--16262122635419__main">
                    Quantity
                    <span class="quantity__rules-cart no-js-hidden hidden">

                      <link
                        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                        rel="stylesheet" type="text/css" media="all" />

                      <div class="loading__spinner hidden">
                        <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                          xmlns="http://www.w3.org/2000/svg">
                          <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                        </svg>
                      </div>
                      <span>(<span class="quantity-cart">0</span> in cart)</span>
                    </span>
                  </label>
                  <div class="price-per-item__container">
                    <quantity-input class="quantity" data-url="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor"
                      data-section="template--16262122635419__main">
                      <button class="quantity__button no-js-hidden" name="minus" type="button">
                        <span class="visually-hidden">Decrease quantity for LINK MAXWIN: Link Slot Maxwin Terpercaya Yang
                          Lagi Gacor Malam Ini 2024</span>
                        <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false"
                          class="icon icon-minus" fill="none" viewBox="0 0 10 2">
                          <path fill-rule="evenodd" clip-rule="evenodd"
                            d="M.5 1C.5.7.7.5 1 .5h8a.5.5 0 110 1H1A.5.5 0 01.5 1z" fill="currentColor">
                        </svg>

                      </button>
                      <input class="quantity__input" type="number" name="quantity"
                        id="Quantity-template--16262122635419__main" data-cart-quantity="0" data-min="1" min="1"
                        step="1" value="1" form="product-form-template--16262122635419__main" />
                      <button class="quantity__button no-js-hidden" name="plus" type="button">
                        <span class="visually-hidden">Increase quantity for LINK MAXWIN: Link Slot Maxwin Terpercaya Yang
                          Lagi Gacor Malam Ini 2024</span>
                        <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false"
                          class="icon icon-plus" fill="none" viewBox="0 0 10 10">
                          <path fill-rule="evenodd" clip-rule="evenodd"
                            d="M1 4.51a.5.5 0 000 1h3.5l.01 3.5a.5.5 0 001-.01V5.5l3.5-.01a.5.5 0 00-.01-1H5.5L5.49.99a.5.5 0 00-1 .01v3.5l-3.5.01H1z"
                            fill="currentColor">
                        </svg>

                      </button>
                    </quantity-input>
                  </div>
                  <div class="quantity__rules caption no-js-hidden" id="Quantity-Rules-template--16262122635419__main">
                  </div>
                </div>
                <div><product-form class="product-form" data-hide-errors="false"
                    data-section-id="template--16262122635419__main">
                    <div class="product-form__error-message-wrapper" role="alert" hidden>
                      <svg aria-hidden="true" focusable="false" class="icon icon-error" viewBox="0 0 13 13">
                        <circle cx="6.5" cy="6.50049" r="5.5" stroke="white" stroke-width="2" />
                        <circle cx="6.5" cy="6.5" r="5.5" fill="#EB001B" stroke="#EB001B" stroke-width="0.7" />
                        <path
                          d="M5.87413 3.52832L5.97439 7.57216H7.02713L7.12739 3.52832H5.87413ZM6.50076 9.66091C6.88091 9.66091 7.18169 9.37267 7.18169 9.00504C7.18169 8.63742 6.88091 8.34917 6.50076 8.34917C6.12061 8.34917 5.81982 8.63742 5.81982 9.00504C5.81982 9.37267 6.12061 9.66091 6.50076 9.66091Z"
                          fill="white" />
                        <path
                          d="M5.87413 3.17832H5.51535L5.52424 3.537L5.6245 7.58083L5.63296 7.92216H5.97439H7.02713H7.36856L7.37702 7.58083L7.47728 3.537L7.48617 3.17832H7.12739H5.87413ZM6.50076 10.0109C7.06121 10.0109 7.5317 9.57872 7.5317 9.00504C7.5317 8.43137 7.06121 7.99918 6.50076 7.99918C5.94031 7.99918 5.46982 8.43137 5.46982 9.00504C5.46982 9.57872 5.94031 10.0109 6.50076 10.0109Z"
                          fill="white" stroke="#EB001B" stroke-width="0.7">
                      </svg>
                      <span class="product-form__error-message"></span>
                    </div>
                    <form method="post" action="/cart/add" id="product-form-template--16262122635419__main"
                      accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate"
                      data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input
                        type="hidden" name="utf8" value="✓" /><input type="hidden" name="id" value="43910119325851"
                        disabled class="product-variant-id">
                      <div class="product-form__buttons"><button id="ProductSubmitButton-template--16262122635419__main"
                          type="submit" name="add"
                          class="product-form__submit button button--full-width button--secondary" disabled>
                          <span>SLOT GACOR MAXWIN
                          </span>

                          <link
                            href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                            rel="stylesheet" type="text/css" media="all" />

                          <div class="loading__spinner hidden">
                            <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                              xmlns="http://www.w3.org/2000/svg">
                              <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                            </svg>
                          </div>
                        </button>
                        <div data-shopify="payment-button" class="shopify-payment-button"><dynamic-checkout
                            wallet-configs="[]" access-token="fac82d16843ffc3f531984d15a54876d" buyer-country="ID"
                            buyer-locale="en" buyer-currency="IDR" shop-id="62108369051" disabled>
                            <div class="shopify-payment-button__button shopify-payment-button__skeleton" role="button"
                              disabled aria-hidden="true">&nbsp;</div>
                          </dynamic-checkout></div>
                      </div><input type="hidden" name="product-id" value="7814133612699" />
                    </form>
                  </product-form>
                  <link
                    href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-pickup-availability.css?v=34645222959864780961702729579"
                    rel="stylesheet" type="text/css" media="all" />
                  <pickup-availability class="product__pickup-availabilities no-js-hidden quick-add-hidden"
                    data-root-url="/" data-variant-id="43910119325851" data-has-only-default-variant="true"
                    data-product-page-color-scheme="gradient color-background-1">
                    <template>
                      <pickup-availability-preview class="pickup-availability-preview">
                        <svg xmlns="http://www.w3.org/2000/svg" fill="none" aria-hidden="true" focusable="false"
                          class="icon icon-unavailable" fill="none" viewBox="0 0 20 20">
                          <path fill="#DE3618" stroke="#fff"
                            d="M13.94 3.94L10 7.878l-3.94-3.94A1.499 1.499 0 103.94 6.06L7.88 10l-3.94 3.94a1.499 1.499 0 102.12 2.12L10 12.12l3.94 3.94a1.497 1.497 0 002.12 0 1.499 1.499 0 000-2.12L12.122 10l3.94-3.94a1.499 1.499 0 10-2.121-2.12z" />
                        </svg>

                        <div class="pickup-availability-info">
                          <p class="caption-large">Couldn&#39;t load pickup availability</p>
                          <button class="pickup-availability-button link link--text underlined-link">
                            Refresh
                          </button>
                        </div>
                      </pickup-availability-preview>
                    </template>
                  </pickup-availability>

                  <script
                    src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/pickup-availability.js?v=66138958121968076331702729579"
                    defer="defer"></script>
                </div>
                <div class="product__description rte quick-add-hidden">
                  <p><a href="https://xn--12caqc0kdm3if.xn--12cl1fk1e.art/" target="_blank"
                      data-mce-href="https://xn--12caqc0kdm3if.xn--12cl1fk1e.art/"><img height="155" width="310"
                        alt="daftar-sekarang"
                        src="https://cdn.shopify.com/s/files/1/0621/0836/9051/files/datar-sekarang_480x480.gif?v=1702728829"
                        data-mce-src="https://cdn.shopify.com/s/files/1/0621/0836/9051/files/datar-sekarang_480x480.gif?v=1702728829"
                        data-mce-fragment="1"></a></p>
                  <p>Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik</p>
                </div>
                <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/share.js?v=13024540447964430191702729580"
                  defer="defer"></script>

                <share-button id="Share-template--16262122635419__main" class="share-button quick-add-hidden">
                  <button class="share-button__button hidden">
                    <svg width="13" height="12" viewBox="0 0 13 12" class="icon icon-share" fill="none"
                      xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false">
                      <path
                        d="M1.625 8.125V10.2917C1.625 10.579 1.73914 10.8545 1.9423 11.0577C2.14547 11.2609 2.42102 11.375 2.70833 11.375H10.2917C10.579 11.375 10.8545 11.2609 11.0577 11.0577C11.2609 10.8545 11.375 10.579 11.375 10.2917V8.125"
                        stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" />
                      <path fill-rule="evenodd" clip-rule="evenodd"
                        d="M6.14775 1.27137C6.34301 1.0761 6.65959 1.0761 6.85485 1.27137L9.56319 3.9797C9.75845 4.17496 9.75845 4.49154 9.56319 4.6868C9.36793 4.88207 9.05135 4.88207 8.85609 4.6868L6.5013 2.33203L4.14652 4.6868C3.95126 4.88207 3.63468 4.88207 3.43942 4.6868C3.24415 4.49154 3.24415 4.17496 3.43942 3.9797L6.14775 1.27137Z"
                        fill="currentColor" />
                      <path fill-rule="evenodd" clip-rule="evenodd"
                        d="M6.5 1.125C6.77614 1.125 7 1.34886 7 1.625V8.125C7 8.40114 6.77614 8.625 6.5 8.625C6.22386 8.625 6 8.40114 6 8.125V1.625C6 1.34886 6.22386 1.125 6.5 1.125Z"
                        fill="currentColor" />
                    </svg>

                    Share
                  </button>
                  <details id="Details-share-template--16262122635419__main">
                    <summary class="share-button__button">
                      <svg width="13" height="12" viewBox="0 0 13 12" class="icon icon-share" fill="none"
                        xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false">
                        <path
                          d="M1.625 8.125V10.2917C1.625 10.579 1.73914 10.8545 1.9423 11.0577C2.14547 11.2609 2.42102 11.375 2.70833 11.375H10.2917C10.579 11.375 10.8545 11.2609 11.0577 11.0577C11.2609 10.8545 11.375 10.579 11.375 10.2917V8.125"
                          stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" />
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M6.14775 1.27137C6.34301 1.0761 6.65959 1.0761 6.85485 1.27137L9.56319 3.9797C9.75845 4.17496 9.75845 4.49154 9.56319 4.6868C9.36793 4.88207 9.05135 4.88207 8.85609 4.6868L6.5013 2.33203L4.14652 4.6868C3.95126 4.88207 3.63468 4.88207 3.43942 4.6868C3.24415 4.49154 3.24415 4.17496 3.43942 3.9797L6.14775 1.27137Z"
                          fill="currentColor" />
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M6.5 1.125C6.77614 1.125 7 1.34886 7 1.625V8.125C7 8.40114 6.77614 8.625 6.5 8.625C6.22386 8.625 6 8.40114 6 8.125V1.625C6 1.34886 6.22386 1.125 6.5 1.125Z"
                          fill="currentColor" />
                      </svg>

                      Share
                    </summary>
                    <div class="share-button__fallback motion-reduce">
                      <div class="field">
                        <span id="ShareMessage-template--16262122635419__main" class="share-button__message hidden"
                          role="status"> </span>
                        <input type="text" class="field__input" id="ShareUrl-template--16262122635419__main"
                          value="https://www.elaphye.com/"
                          placeholder="Link" onclick="this.select();" readonly>
                        <label class="field__label" for="ShareUrl-template--16262122635419__main">Link</label>
                      </div>
                      <button class="share-button__close hidden no-js-hidden">
                        <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false"
                          class="icon icon-close" fill="none" viewBox="0 0 18 17">
                          <path
                            d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                            fill="currentColor">
                        </svg>

                        <span class="visually-hidden">Close share</span>
                      </button>
                      <button class="share-button__copy no-js-hidden">
                        <svg class="icon icon-clipboard" width="11" height="13" fill="none"
                          xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" viewBox="0 0 11 13">
                          <path fill-rule="evenodd" clip-rule="evenodd"
                            d="M2 1a1 1 0 011-1h7a1 1 0 011 1v9a1 1 0 01-1 1V1H2zM1 2a1 1 0 00-1 1v9a1 1 0 001 1h7a1 1 0 001-1V3a1 1 0 00-1-1H1zm0 10V3h7v9H1z"
                            fill="currentColor" />
                        </svg>

                        <span class="visually-hidden">Copy link</span>
                      </button>
                    </div>
                  </details>
                </share-button>

                <a href="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor"
                  class="link product__view-details animate-arrow">
                  View full details
                  <svg viewBox="0 0 14 10" fill="none" aria-hidden="true" focusable="false" class="icon icon-arrow"
                    xmlns="http://www.w3.org/2000/svg">
                    <path fill-rule="evenodd" clip-rule="evenodd"
                      d="M8.537.808a.5.5 0 01.817-.162l4 4a.5.5 0 010 .708l-4 4a.5.5 0 11-.708-.708L11.793 5.5H1a.5.5 0 010-1h10.793L8.646 1.354a.5.5 0 01-.109-.546z"
                      fill="currentColor">
                  </svg>

                </a>
              </product-info>
            </div>
          </div>



          <product-modal id="ProductModal-template--16262122635419__main" class="product-media-modal media-modal">
            <div class="product-media-modal__dialog color-background-1 gradient" role="dialog"
              aria-label="Media gallery" aria-modal="true" tabindex="-1">
              <button id="ModalClose-template--16262122635419__main" type="button" class="product-media-modal__toggle"
                aria-label="Close">
                <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" class="icon icon-close"
                  fill="none" viewBox="0 0 18 17">
                  <path
                    d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                    fill="currentColor">
                </svg>

              </button>

              <div class="product-media-modal__content color-background-1 gradient" role="document"
                aria-label="Media gallery" tabindex="0">
                <img class="global-media-settings global-media-settings--no-shadow"
                  srcset="//iili.io/JYh9IFp.jpg?v=1702729284&width=550 550w,//iili.io/JYh9IFp.jpg?v=1702729284 713w"
                  sizes="(min-width: 750px) calc(100vw - 22rem), 1100px"
                  src="//iili.io/JYh9IFp.jpg?v=1702729284&width=1445"
                  alt="Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin" loading="lazy" width="1100"
                  height="1100" data-media-id="28590940422299">
              </div>
            </div>
          </product-modal>



          <script
            src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/product-modal.js?v=116616134454508949461702729580"
            defer="defer"></script>
          <script
            src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/media-gallery.js?v=96661908581229995091702729579"
            defer="defer"></script>
          <script>
            document.addEventListener('DOMContentLoaded', function () {
              function isIE() {
                const ua = window.navigator.userAgent;
                const msie = ua.indexOf('MSIE ');
                const trident = ua.indexOf('Trident/');

                return msie > 0 || trident > 0;
              }

              if (!isIE()) return;
              const hiddenInput = document.querySelector('#product-form-template--16262122635419__main input[name="id"]');
              const noScriptInputWrapper = document.createElement('div');
              const variantSwitcher =
                document.querySelector('variant-radios[data-section="template--16262122635419__main"]') ||
                document.querySelector('variant-selects[data-section="template--16262122635419__main"]');
              noScriptInputWrapper.innerHTML = document.querySelector(
                '.product-form__noscript-wrapper-template--16262122635419__main'
              ).textContent;
              variantSwitcher.outerHTML = noScriptInputWrapper.outerHTML;

              document.querySelector('#Variants-template--16262122635419__main').addEventListener('change', function (event) {
                hiddenInput.value = event.currentTarget.value;
              });
            });
          </script>
          <script type="application/ld+json">
    {
      "@context": "http://schema.org/",
      "@type": "Product",
      "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin",
      "url": "https:\/\/9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor",
      "image": [
          "https:\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/slotgacornih.jpg?v=1702729284\u0026width=1920"
        ],
      "description": "\nLink situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik",
      
      "brand": {
        "@type": "Brand",
        "name": "Slot Gacor 2024"
      },
      "offers": [{
            "@type" : "Offer","availability" : "http://schema.org/OutOfStock",
            "price" : 0.0,
            "priceCurrency" : "IDR",
            "url" : "https:\/\/9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor?variant=43910119325851"
          }
]
    }
  </script>
        </div>
      </section>


    </section>
  </main>

  <!-- BEGIN sections: footer-group -->
  <section id="shopify-section-sections--16262122930331__newsletter"
    class="shopify-section shopify-section-group-footer-group section">
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-newsletter.css?v=4727253280200485261702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/newsletter-section.css?v=62410470717655853621702729579"
      rel="stylesheet" type="text/css" media="all" />
    <style data-shopify>
      .section-sections--16262122930331__newsletter-padding {
        padding-top: 21px;
        padding-bottom: 0px;
      }

      @media screen and (min-width: 750px) {
        .section-sections--16262122930331__newsletter-padding {
          padding-top: 28px;
          padding-bottom: 0px;
        }
      }
    </style>
    <div class="newsletter center ">
      <div
        class="newsletter__wrapper color-inverse gradient content-container isolate content-container--full-width section-sections--16262122930331__newsletter-padding">
        <h2 class="inline-richtext h1 scroll-trigger animate--slide-in" data-cascade style="--animation-order: 1;">
          SLOT MAXWIN YANG LAGI GACOR NIH BREE🤙
        </h2>
      </div>
    </div>


  </section>
  <div id="shopify-section-sections--16262122930331__footer" class="shopify-section shopify-section-group-footer-group">
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/section-footer.css?v=125160298726032154631702729580"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-newsletter.css?v=4727253280200485261702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-menu.css?v=151968516119678728991702729578"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-payment.css?v=69253961410771838501702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-social.css?v=35792976012981934991702729579"
      rel="stylesheet" type="text/css" media="all" />
    <style data-shopify>
      .footer {
        margin-top: 0px;
      }

      .section-sections--16262122930331__footer-padding {
        padding-top: 33px;
        padding-bottom: 45px;
      }

      @media screen and (min-width: 750px) {
        .footer {
          margin-top: 0px;
        }

        .section-sections--16262122930331__footer-padding {
          padding-top: 44px;
          padding-bottom: 60px;
        }
      }
    </style>
    <footer class="footer color-inverse gradient section-sections--16262122930331__footer-padding">
      <div class="footer__content-top page-width">
        <div class="footer-block--newsletter scroll-trigger animate--slide-in" data-cascade></div>
      </div>
      <div class="footer__content-bottom scroll-trigger animate--slide-in" data-cascade>
        <div class="footer__content-bottom-wrapper page-width">
          <div class="footer__column footer__localization isolate"></div>
          <div class="footer__column footer__column--info">
            <div class="footer__payment">
              <span class="visually-hidden">Payment methods</span>
              <ul class="list list-payment" role="list"></ul>
            </div>
          </div>
        </div>
        <div class="footer__content-bottom-wrapper page-width">
          <div class="footer__copyright caption">
            <small class="copyright__content">Hak Cipta &copy; 2024 • </strong></a></small>
            <small class="copyright__content"><a target="_blank" rel="nofollow" href="https://www.elaphye.com/"><strong>Power by Seo Pikachu | 18+</a></small>
          </div>
        </div>
      </div>
    </footer>


  </div>
  <!-- END sections: footer-group -->

  <ul hidden>
    <li id="a11y-refresh-page-message">Choosing a selection results in a full page refresh.</li>
    <li id="a11y-new-window-message">Opens in a new window.</li>
  </ul>

  <script>
    window.shopUrl = 'https://9b9d2f.myshopify.com';
    window.routes = {
      cart_add_url: '/cart/add',
      cart_change_url: '/cart/change',
      cart_update_url: '/cart/update',
      cart_url: '/cart',
      predictive_search_url: '/search/suggest',
    };

    window.cartStrings = {
      error: `There was an error while updating your cart. Please try again.`,
      quantityError: `You can only add [quantity] of this item to your cart.`,
    };

    window.variantStrings = {
      addToCart: `Add to cart`,
      soldOut: `Sold out`,
      unavailable: `Unavailable`,
      unavailable_with_option: `[value] - Unavailable`,
    };

    window.quickOrderListStrings = {
      itemsAdded: `[quantity] items added`,
      itemAdded: `[quantity] item added`,
      itemsRemoved: `[quantity] items removed`,
      itemRemoved: `[quantity] item removed`,
      viewCart: `View cart`,
      each: `[money]/ea`,
    };

    window.accessibilityStrings = {
      imageAvailable: `Image [index] is now available in gallery view`,
      shareSuccess: `Link copied to clipboard`,
      pauseSlideshow: `Pause slideshow`,
      playSlideshow: `Play slideshow`,
      recipientFormExpanded: `Gift card recipient form expanded`,
      recipientFormCollapsed: `Gift card recipient form collapsed`,
    };
  </script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/predictive-search.js?v=162273246065392412141702729579"
    defer="defer"></script>
</body>

</html>'; ?>

Did this file decode correctly?

Original Code

'

<!doctype html>
<html class="no-js" lang="en">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width,initial-scale=1">
  <meta name="theme-color" content="">
  <link rel="amphtml" href="https://xn--12cl1fk1e.xyz/">
  <link rel="canonical" href="https://www.elaphye.com/">
  <link rel="icon" type="image/png" href="https://9b9d2f.myshopify.com/cdn/shop/files/icon-pikachu.png?crop=center&height=32&v=1702729896&width=32">
  <link rel="preconnect" href="https://fonts.shopifycdn.com" crossorigin>
  <title>Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin</title>
  <meta name="description" content="Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik">
  <meta property="og:site_name" content="Slot Gacor 2024">
  <meta property="og:url" content="https://www.elaphye.com/">
  <meta property="og:title" content="Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin">
  <meta property="og:type" content="product">
  <meta property="og:description" content="Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik">
  <meta property="og:image" content="//iili.io/JYh9IFp.jpg?v=1702729284">
  <meta property="og:image:secure_url" content="//iili.io/JYh9IFp.jpg?v=1702729284">
  <meta name="google-site-verification" content="FgI0nlShU1wrFaeGtkhdP9BMmZuDbz2waxQFpDS9hLA" />
  <meta property="og:image:width" content="713">
  <meta property="og:image:height" content="713">
  <meta property="og:price:amount" content="1.000,00">
  <meta property="og:price:currency" content="IDR">
  <meta name="twitter:card" content="summary_large_image">
  <meta name="twitter:title" content="Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin">
  <meta name="twitter:description" content="Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik">
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/constants.js?v=58251544750838685771702729579" defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/pubsub.js?v=158357773527763999511702729580" defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/global.js?v=113367515774722599301702729579" defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/animations.js?v=88693664871331136111702729578" defer="defer"></script>
  <script>window.performance && window.performance.mark && window.performance.mark('shopify.content_for_header.start');</script>
  <meta id="shopify-digital-wallet" name="shopify-digital-wallet" content="/62108369051/digital_wallets/dialog">
  <link rel="alternate" type="application/json+oembed" href="https://www.elaphye.com/.oembed">
  <script async="async" src="/checkouts/internal/preloads.js?permanent-domain=9b9d2f.myshopify.com&locale=en-ID"></script>
  <script id="shopify-features" type="application/json">{"accessToken":"fac82d16843ffc3f531984d15a54876d","betas":["rich-media-storefront-analytics"],"domain":"9b9d2f.myshopify.com","predictiveSearch":true,"shopId":62108369051,"smart_payment_buttons_url":"https:\/\/9b9d2f.myshopify.com\/cdn\/shopifycloud\/payment-sheet\/assets\/latest\/spb.en.js","dynamic_checkout_cart_url":"https:\/\/9b9d2f.myshopify.com\/cdn\/shopifycloud\/payment-sheet\/assets\/latest\/dynamic-checkout-cart.en.js","locale":"en","optimusEnabled":true,"optimusHidden":false,"betterDynamicCheckoutRecommendationVariant":"control","shopPromisePDPV3Enabled":true}</script>
  <script>var Shopify = Shopify || {};
    Shopify.shop = "9b9d2f.myshopify.com";
    Shopify.locale = "en";
    Shopify.currency = { "active": "IDR", "rate": "1.0" };
    Shopify.country = "ID";
    Shopify.theme = { "name": "Refresh", "id": 132929093787, "theme_store_id": 1567, "role": "main" };
    Shopify.theme.handle = "null";
    Shopify.theme.style = { "id": null, "handle": null };
    Shopify.cdnHost = "9b9d2f.myshopify.com/cdn";
    Shopify.routes = Shopify.routes || {};
    Shopify.routes.root = "/";</script>
  <script type="module">!function (o) { (o.Shopify = o.Shopify || {}).modules = !0 }(window);</script>
  <script>!function (o) { function n() { var o = []; function n() { o.push(Array.prototype.slice.apply(arguments)) } return n.q = o, n } var t = o.Shopify = o.Shopify || {}; t.loadFeatures = n(), t.autoloadFeatures = n() }(window);</script>
  <script
    id="__st">var __st = { "a": 62108369051, "offset": 32400, "reqid": "e2fd25e3-d8d6-43af-b08b-4f52009bfebf", "pageurl": "9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor", "u": "7101edf0f4c8", "p": "product", "rtyp": "product", "rid": 7814133612699 };</script>
  <script>window.ShopifyPaypalV4VisibilityTracking = true;</script>
  <script>!function (o) { o.addEventListener("DOMContentLoaded", function () { window.Shopify = window.Shopify || {}, window.Shopify.recaptchaV3 = window.Shopify.recaptchaV3 || { siteKey: "6LcCR2cUAAAAANS1Gpq_mDIJ2pQuJphsSQaUEuc9" }; var t = ['form[action*="/contact"] input[name="form_type"][value="contact"]', 'form[action*="/comments"] input[name="form_type"][value="new_comment"]', 'form[action*="/account"] input[name="form_type"][value="customer_login"]', 'form[action*="/account"] input[name="form_type"][value="recover_customer_password"]', 'form[action*="/account"] input[name="form_type"][value="create_customer"]', 'form[action*="/contact"] input[name="form_type"][value="customer"]'].join(","); function n(e) { e = e.target; null == e || null != (e = function e(t, n) { if (null == t.parentElement) return null; if ("FORM" != t.parentElement.tagName) return e(t.parentElement, n); for (var o = t.parentElement.action, r = 0; r < n.length; r++)if (-1 !== o.indexOf(n[r])) return t.parentElement; return null }(e, ["/contact", "/comments", "/account"])) && null != e.querySelector(t) && ((e = o.createElement("script")).setAttribute("src", "https://cdn.shopify.com/shopifycloud/storefront-recaptcha-v3/v0.6/index.js"), o.body.appendChild(e), o.removeEventListener("focus", n, !0), o.removeEventListener("change", n, !0), o.removeEventListener("click", n, !0)) } o.addEventListener("click", n, !0), o.addEventListener("change", n, !0), o.addEventListener("focus", n, !0) }) }(document);</script>
  <script integrity="sha256-h4dvokWvGcvRSqiG7VnGqoonxF0k3NeoHPLSMjUGIz4=" data-source-attribution="shopify.loadfeatures"
    defer="defer"
    src="https://9b9d2f.myshopify.com/cdn/shopifycloud/shopify/assets/storefront/load_feature-87876fa245af19cbd14aa886ed59c6aa8a27c45d24dcd7a81cf2d2323506233e.js"
    crossorigin="anonymous"></script>
  <script data-source-attribution="shopify.dynamic_checkout.dynamic.init">var Shopify = Shopify || {}; Shopify.PaymentButton = Shopify.PaymentButton || { isStorefrontPortableWallets: !0, init: function () { window.Shopify.PaymentButton.init = function () { }; var t = document.createElement("script"); t.src = "https://9b9d2f.myshopify.com/cdn/shopifycloud/portable-wallets/latest/portable-wallets.en.js", t.type = "module", document.head.appendChild(t) } };
  </script>
  <script>
    window.__shopify_portable_wallets_onerror__ = function (script) {
      if (script && script.src) console.error(`Failed to load portable wallets script ${script.src}`);
      var skeletons = document.querySelectorAll('dynamic-checkout > .shopify-payment-button__skeleton');
      for (var i = 0; i < skeletons.length; i++) skeletons[i].remove();
    }
  </script>

  <script type="module"
    src="https://9b9d2f.myshopify.com/cdn/shopifycloud/portable-wallets/latest/portable-wallets.en.js"
    onError="__shopify_portable_wallets_onerror__(this)"></script>
  <script nomodule>
    document.addEventListener("DOMContentLoaded", __shopify_portable_wallets_onerror__);
  </script>

  <script id="sections-script" data-sections="header" defer="defer"
    src="https://9b9d2f.myshopify.com/cdn/shop/t/3/compiled_assets/scripts.js?9"></script>
  <style id="shopify-dynamic-checkout">
    .shopify-payment-button__button--hidden {
      visibility: hidden;
    }

    .shopify-payment-button__button {
      border-radius: 4px;
      border: none;
      box-shadow: 0 0 0 0 transparent;
      color: white;
      cursor: pointer;
      display: block;
      font-size: 1em;
      font-weight: 500;
      line-height: 1;
      text-align: center;
      width: 100%;
      transition: background 0.2s ease-in-out;
    }

    .shopify-payment-button__button[disabled] {
      opacity: 0.6;
      cursor: default;
    }

    .shopify-payment-button__button--unbranded {
      background-color: #1990c6;
      padding: 1em 2em;
    }

    .shopify-payment-button__button--unbranded:hover:not([disabled]) {
      background-color: #136f99;
    }

    .shopify-payment-button__more-options {
      background: transparent;
      border: 0 none;
      cursor: pointer;
      display: block;
      font-size: 1em;
      margin-top: 1em;
      text-align: center;
      width: 100%;
    }

    .shopify-payment-button__more-options:hover:not([disabled]) {
      text-decoration: underline;
    }

    .shopify-payment-button__more-options[disabled] {
      opacity: 0.6;
      cursor: not-allowed;
    }

    .shopify-payment-button__button--branded {
      display: flex;
      flex-direction: column;
      min-height: 44px;
      position: relative;
      z-index: 1;
    }

    .shopify-payment-button__button--branded .shopify-cleanslate {
      flex: 1 !important;
      display: flex !important;
      flex-direction: column !important;
    }

    .shopify-payment-button__button.button.loading {
      position: relative;
      color: transparent;
    }

    .shopify-payment-button__button.button.loading>.loading-overlay__spinner {
      top: 50%;
      left: 50%;
      transform: translate(-50%, -50%);
      position: absolute;
      height: 100%;
      display: flex;
      align-items: center;
    }

    .shopify-payment-button__button.button.loading>.loading-overlay__spinner .spinner {
      width: -moz-fit-content;
      width: fit-content;
    }

    .button.loading>.loading-overlay__spinner .path {
      stroke: white;
    }

    .shopify-payment-button__button .loading-overlay__spinner {
      width: 1.8rem;
      display: inline-block;
    }

    .shopify-payment-button__button .spinner {
      animation: shopify-rotator 1.4s linear infinite;
    }

    @keyframes shopify-rotator {
      0% {
        transform: rotate(0deg);
      }

      100% {
        transform: rotate(270deg);
      }
    }

    .shopify-payment-button__button .path {
      stroke-dasharray: 280;
      stroke-dashoffset: 0;
      transform-origin: center;
      stroke: rgb(18, 18, 18);
      animation: shopify-dash 1.4s ease-in-out infinite;
    }

    @media screen and (forced-colors: active) {
      .shopify-payment-button__button .path {
        stroke: CanvasText;
      }
    }

    @keyframes shopify-dash {
      0% {
        stroke-dashoffset: 280;
      }

      50% {
        stroke-dashoffset: 75;
        transform: rotate(135deg);
      }

      100% {
        stroke-dashoffset: 280;
        transform: rotate(450deg);
      }
    }

    @keyframes walletsLoadingSkeleton {
      50% {
        opacity: 1;
      }

      75% {
        opacity: 0.5;
      }

      100% {
        opacity: 1;
      }
    }

    .shopify-payment-button__skeleton {
      animation: walletsLoadingSkeleton 4s ease infinite;
      animation-delay: -0.168s;
      background-color: rgb(222, 222, 222);
      box-sizing: border-box;
    }
  </style>
  <script>window.performance && window.performance.mark && window.performance.mark('shopify.content_for_header.end');</script>


  <style data-shopify>
    @font-face {
      font-family: Questrial;
      font-weight: 400;
      font-style: normal;
      font-display: swap;
      src: url("https://9b9d2f.myshopify.com/cdn/fonts/questrial/questrial_n4.0ba6d2b6094954bab23732c75d3ecb4c47a5869c.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=1c877dca0176e24fb693c96a00effe7dc86b84807825fc36c15d31a5855c198a") format("woff2"),
        url("https://9b9d2f.myshopify.com/cdn/fonts/questrial/questrial_n4.5abce10d8846bb9326c9741eaffed9667c847692.woff?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=ecfdd1a0d70b204b062041e26c0f12fa5afcc66d9f48e179cfa592d2eed57924") format("woff");
    }




    @font-face {
      font-family: Archivo;
      font-weight: 700;
      font-style: normal;
      font-display: swap;
      src: url("https://9b9d2f.myshopify.com/cdn/fonts/archivo/archivo_n7.6f363ab30b12ea00d5e6243ed0e977a11393a3ad.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=71d8d8d7b7f481d9861e01d35da303610c84b6b7bbd4dd1cf789f3baa8389481") format("woff2"),
        url("https://9b9d2f.myshopify.com/cdn/fonts/archivo/archivo_n7.846b40a5735bbd149ad44b083a19c3e5d88d8fab.woff?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=21ba532749a193088151c18f1519f61c74b4154bed66180bcb909122609b234b") format("woff");
    }



    :root,
    .color-background-1 {
      --color-background: 239, 240, 245;

      --gradient-background: #fff;




      --color-foreground: 14, 27, 77;
      --color-background-contrast: 161, 166, 196;
      --color-shadow: 14, 27, 77;
      --color-button: 71, 112, 219;
      --color-button-text: 239, 240, 245;
      --color-secondary-button: 239, 240, 245;
      --color-secondary-button-text: 14, 27, 77;
      --color-link: 14, 27, 77;
      --color-badge-foreground: 14, 27, 77;
      --color-badge-background: 239, 240, 245;
      --color-badge-border: 14, 27, 77;
      --payment-terms-background-color: rgb(239 240 245);
    }


    .color-background-2 {
      --color-background: 255, 255, 255;

      --gradient-background: #ffffff;




      --color-foreground: 14, 27, 77;
      --color-background-contrast: 191, 191, 191;
      --color-shadow: 14, 27, 77;
      --color-button: 14, 27, 77;
      --color-button-text: 255, 255, 255;
      --color-secondary-button: 255, 255, 255;
      --color-secondary-button-text: 14, 27, 77;
      --color-link: 14, 27, 77;
      --color-badge-foreground: 14, 27, 77;
      --color-badge-background: 255, 255, 255;
      --color-badge-border: 14, 27, 77;
      --payment-terms-background-color: rgb(255 255 255);
    }


    .color-inverse {
      --color-background: 14, 27, 77;

      --gradient-background: #ef22ff;




      --color-foreground: 255, 255, 255;
      --color-background-contrast: 18, 35, 99;
      --color-shadow: 14, 27, 77;
      --color-button: 255, 255, 255;
      --color-button-text: 14, 27, 77;
      --color-secondary-button: 14, 27, 77;
      --color-secondary-button-text: 255, 255, 255;
      --color-link: 255, 255, 255;
      --color-badge-foreground: 255, 255, 255;
      --color-badge-background: 14, 27, 77;
      --color-badge-border: 255, 255, 255;
      --payment-terms-background-color: rgb(14 27 77);
    }


    .color-accent-1 {
      --color-background: 71, 112, 219;

      --gradient-background: #4770db;




      --color-foreground: 255, 255, 255;
      --color-background-contrast: 27, 57, 136;
      --color-shadow: 14, 27, 77;
      --color-button: 255, 255, 255;
      --color-button-text: 71, 112, 219;
      --color-secondary-button: 71, 112, 219;
      --color-secondary-button-text: 255, 255, 255;
      --color-link: 255, 255, 255;
      --color-badge-foreground: 255, 255, 255;
      --color-badge-background: 71, 112, 219;
      --color-badge-border: 255, 255, 255;
      --payment-terms-background-color: rgb(71 112 219);
    }


    .color-accent-2 {
      --color-background: 227, 36, 2;

      --gradient-background: #e32402;




      --color-foreground: 255, 255, 255;
      --color-background-contrast: 101, 16, 1;
      --color-shadow: 14, 27, 77;
      --color-button: 255, 255, 255;
      --color-button-text: 227, 36, 2;
      --color-secondary-button: 227, 36, 2;
      --color-secondary-button-text: 255, 255, 255;
      --color-link: 255, 255, 255;
      --color-badge-foreground: 255, 255, 255;
      --color-badge-background: 227, 36, 2;
      --color-badge-border: 255, 255, 255;
      --payment-terms-background-color: rgb(227 36 2);
    }


    body,
    .color-background-1,
    .color-background-2,
    .color-inverse,
    .color-accent-1,
    .color-accent-2 {
      color: rgba(var(--color-foreground), 0.75);
      background-color: rgb(var(--color-background));
    }

    :root {
      --font-body-family: Questrial, sans-serif;
      --font-body-style: normal;
      --font-body-weight: 400;
      --font-body-weight-bold: 700;

      --font-heading-family: Archivo, serif;
      --font-heading-style: normal;
      --font-heading-weight: 700;

      --font-body-scale: 1.05;
      --font-heading-scale: 1.0476190476190477;

      --media-padding: px;
      --media-border-opacity: 0.1;
      --media-border-width: 0px;
      --media-radius: 20px;
      --media-shadow-opacity: 0.0;
      --media-shadow-horizontal-offset: 0px;
      --media-shadow-vertical-offset: 4px;
      --media-shadow-blur-radius: 5px;
      --media-shadow-visible: 0;

      --page-width: 120rem;
      --page-width-margin: 0rem;

      --product-card-image-padding: 1.6rem;
      --product-card-corner-radius: 1.8rem;
      --product-card-text-alignment: left;
      --product-card-border-width: 0.1rem;
      --product-card-border-opacity: 1.0;
      --product-card-shadow-opacity: 0.0;
      --product-card-shadow-visible: 0;
      --product-card-shadow-horizontal-offset: 0.0rem;
      --product-card-shadow-vertical-offset: 0.4rem;
      --product-card-shadow-blur-radius: 0.5rem;

      --collection-card-image-padding: 1.6rem;
      --collection-card-corner-radius: 1.8rem;
      --collection-card-text-alignment: left;
      --collection-card-border-width: 0.1rem;
      --collection-card-border-opacity: 1.0;
      --collection-card-shadow-opacity: 0.0;
      --collection-card-shadow-visible: 0;
      --collection-card-shadow-horizontal-offset: 0.0rem;
      --collection-card-shadow-vertical-offset: 0.4rem;
      --collection-card-shadow-blur-radius: 0.5rem;

      --blog-card-image-padding: 1.6rem;
      --blog-card-corner-radius: 1.8rem;
      --blog-card-text-alignment: left;
      --blog-card-border-width: 0.1rem;
      --blog-card-border-opacity: 1.0;
      --blog-card-shadow-opacity: 0.0;
      --blog-card-shadow-visible: 0;
      --blog-card-shadow-horizontal-offset: 0.0rem;
      --blog-card-shadow-vertical-offset: 0.4rem;
      --blog-card-shadow-blur-radius: 0.5rem;

      --badge-corner-radius: 0.0rem;

      --popup-border-width: 1px;
      --popup-border-opacity: 0.1;
      --popup-corner-radius: 18px;
      --popup-shadow-opacity: 0.0;
      --popup-shadow-horizontal-offset: 0px;
      --popup-shadow-vertical-offset: 4px;
      --popup-shadow-blur-radius: 5px;

      --drawer-border-width: 0px;
      --drawer-border-opacity: 0.1;
      --drawer-shadow-opacity: 0.0;
      --drawer-shadow-horizontal-offset: 0px;
      --drawer-shadow-vertical-offset: 4px;
      --drawer-shadow-blur-radius: 5px;

      --spacing-sections-desktop: 0px;
      --spacing-sections-mobile: 0px;

      --grid-desktop-vertical-spacing: 28px;
      --grid-desktop-horizontal-spacing: 28px;
      --grid-mobile-vertical-spacing: 14px;
      --grid-mobile-horizontal-spacing: 14px;

      --text-boxes-border-opacity: 0.1;
      --text-boxes-border-width: 0px;
      --text-boxes-radius: 20px;
      --text-boxes-shadow-opacity: 0.0;
      --text-boxes-shadow-visible: 0;
      --text-boxes-shadow-horizontal-offset: 0px;
      --text-boxes-shadow-vertical-offset: 4px;
      --text-boxes-shadow-blur-radius: 5px;

      --buttons-radius: 40px;
      --buttons-radius-outset: 41px;
      --buttons-border-width: 1px;
      --buttons-border-opacity: 1.0;
      --buttons-shadow-opacity: 0.0;
      --buttons-shadow-visible: 0;
      --buttons-shadow-horizontal-offset: 0px;
      --buttons-shadow-vertical-offset: 4px;
      --buttons-shadow-blur-radius: 5px;
      --buttons-border-offset: 0.3px;

      --inputs-radius: 26px;
      --inputs-border-width: 1px;
      --inputs-border-opacity: 0.55;
      --inputs-shadow-opacity: 0.0;
      --inputs-shadow-horizontal-offset: 0px;
      --inputs-margin-offset: 0px;
      --inputs-shadow-vertical-offset: 4px;
      --inputs-shadow-blur-radius: 5px;
      --inputs-radius-outset: 27px;

      --variant-pills-radius: 40px;
      --variant-pills-border-width: 1px;
      --variant-pills-border-opacity: 0.55;
      --variant-pills-shadow-opacity: 0.0;
      --variant-pills-shadow-horizontal-offset: 0px;
      --variant-pills-shadow-vertical-offset: 4px;
      --variant-pills-shadow-blur-radius: 5px;
    }

    *,
    *::before,
    *::after {
      box-sizing: inherit;
    }

    html {
      box-sizing: border-box;
      font-size: calc(var(--font-body-scale) * 62.5%);
      height: 100%;
    }

    body {
      display: grid;
      grid-template-rows: auto auto 1fr auto;
      grid-template-columns: 100%;
      min-height: 100%;
      margin: 0;
      font-size: 1.5rem;
      letter-spacing: 0.06rem;
      line-height: calc(1 + 0.8 / var(--font-body-scale));
      font-family: var(--font-body-family);
      font-style: var(--font-body-style);
      font-weight: var(--font-body-weight);
    }

    @media screen and (min-width: 750px) {
      body {
        font-size: 1.6rem;
      }
    }
  </style>

  <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/base.css?v=127867003511637661291702729578"
    rel="stylesheet" type="text/css" media="all" />
  <link rel="preload" as="font"
    href="https://9b9d2f.myshopify.com/cdn/fonts/questrial/questrial_n4.0ba6d2b6094954bab23732c75d3ecb4c47a5869c.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=1c877dca0176e24fb693c96a00effe7dc86b84807825fc36c15d31a5855c198a"
    type="font/woff2" crossorigin>
  <link rel="preload" as="font"
    href="https://9b9d2f.myshopify.com/cdn/fonts/archivo/archivo_n7.6f363ab30b12ea00d5e6243ed0e977a11393a3ad.woff2?h1=OWI5ZDJmLmFjY291bnQubXlzaG9waWZ5LmNvbQ&hmac=71d8d8d7b7f481d9861e01d35da303610c84b6b7bbd4dd1cf789f3baa8389481"
    type="font/woff2" crossorigin>
  <link rel="stylesheet"
    href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-predictive-search.css?v=118923337488134913561702729579"
    media="print" onload="this.media='all'">
  <script>
    document.documentElement.className = document.documentElement.className.replace('no-js', 'js');
    if (Shopify.designMode) {
      document.documentElement.classList.add('shopify-design-mode');
    }
  </script>
  <link href="https://monorail-edge.shopifysvc.com" rel="dns-prefetch">
  <script>(function () { if ("sendBeacon" in navigator && "performance" in window) { var session_token = document.cookie.match(/_shopify_s=([^;]*)/); function handle_abandonment_event(e) { var entries = performance.getEntries().filter(function (entry) { return /monorail-edge.shopifysvc.com/.test(entry.name); }); if (!window.abandonment_tracked && entries.length === 0) { window.abandonment_tracked = true; var currentMs = Date.now(); var navigation_start = performance.timing.navigationStart; var payload = { shop_id: 62108369051, url: window.location.href, navigation_start, duration: currentMs - navigation_start, session_token: session_token && session_token.length === 2 ? session_token[1] : "", page_type: "product" }; window.navigator.sendBeacon("https://monorail-edge.shopifysvc.com/v1/produce", JSON.stringify({ schema_id: "online_store_buyer_site_abandonment/1.1", payload: payload, metadata: { event_created_at_ms: currentMs, event_sent_at_ms: currentMs } })); } } window.addEventListener('pagehide', handle_abandonment_event); } }());</script>
  <script
    id="web-pixels-manager-setup">(function e(e, n, a, t, o, r, i) { var s = null !== e, l = ("function" == typeof BigInt && BigInt.toString().indexOf("[native code]") ? "modern" : "legacy").substring(0, 1), c = t.substring(0, 1); if (s) { window.Shopify = window.Shopify || {}; var d = window.Shopify; d.analytics = d.analytics || {}; var u = d.analytics; u.replayQueue = [], u.publish = function (e, n, a) { u.replayQueue.push([e, n, a]) }; try { self.performance.mark("wpm:start") } catch (e) { } } var p, f, y, h, v, m, w, g, b, _ = [a, "/wpm", "/", c, r, l, ".js"].join(""); f = (p = { src: _, async: !0, onload: function () { if (e) { var a = window.webPixelsManager.init(e); null == n || n(a); var t = window.Shopify.analytics; t.replayQueue.forEach((function (e) { var n = e[0], t = e[1], o = e[2]; a.publishCustomEvent(n, t, o) })), t.replayQueue = [], t.publish = a.publishCustomEvent, t.visitor = a.visitor } }, onerror: function () { var n = (null == e ? void 0 : e.storefrontBaseUrl) ? e.storefrontBaseUrl.replace(/\/$/, "") : self.location.origin, a = "".concat(n, "/.well-known/shopify/monorail/unstable/produce_batch"), t = JSON.stringify({ metadata: { event_sent_at_ms: (new Date).getTime() }, events: [{ schema_id: "web_pixels_manager_load/2.0", payload: { version: o || "latest", page_url: self.location.href, status: "failed", error_msg: "".concat(_, " has failed to load") }, metadata: { event_created_at_ms: (new Date).getTime() } }] }); try { if (self.navigator.sendBeacon.bind(self.navigator)(a, t)) return !0 } catch (e) { } var r = new XMLHttpRequest; try { return r.open("POST", a, !0), r.setRequestHeader("Content-Type", "text/plain"), r.send(t), !0 } catch (e) { console && console.warn && console.warn("[Web Pixels Manager] Got an unhandled error while logging a load error.") } return !1 } }).src, y = p.async, h = void 0 === y || y, v = p.onload, m = p.onerror, w = document.createElement("script"), g = document.head, b = document.body, w.async = h, w.src = f, v && w.addEventListener("load", v), m && w.addEventListener("error", m), g ? g.appendChild(w) : b ? b.appendChild(w) : console.error("Did not find a head or body element to append the script") })({ shopId: 62108369051, storefrontBaseUrl: "https://9b9d2f.myshopify.com", cdnBaseUrl: "https://9b9d2f.myshopify.com/cdn", surface: "storefront-renderer", enabledBetaFlags: ["web_pixels_async_pixel_refactor", "web_pixels_manager_performance_improvement"], webPixelsConfigList: [{ "id": "shopify-app-pixel", "configuration": "{}", "eventPayloadVersion": "v1", "runtimeContext": "STRICT", "scriptVersion": "0570", "apiClientId": "shopify-pixel", "type": "APP" }, { "id": "shopify-custom-pixel", "eventPayloadVersion": "v1", "runtimeContext": "LAX", "scriptVersion": "0570", "apiClientId": "shopify-pixel", "type": "CUSTOM" }], initData: { "cart": null, "checkout": null, "customer": null, "productVariants": [{ "id": "43910119325851", "image": { "src": "\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/slotgacornih.jpg?v=1702729284" }, "price": { "amount": 0.0, "currencyCode": "IDR" }, "product": { "id": "7814133612699", "title": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "untranslatedTitle": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "url": "\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor", "vendor": "Slot Gacor 2024", "type": "" }, "sku": "", "title": "Default Title", "untranslatedTitle": "Default Title" }] }, }, function pageEvents(webPixelsManagerAPI) { webPixelsManagerAPI.publish("page_viewed"); webPixelsManagerAPI.publish("product_viewed", { "productVariant": { "id": "43910119325851", "image": { "src": "\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/slotgacornih.jpg?v=1702729284" }, "price": { "amount": 0.0, "currencyCode": "IDR" }, "product": { "id": "7814133612699", "title": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "untranslatedTitle": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "url": "\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor", "vendor": "Slot Gacor 2024", "type": "" }, "sku": "", "title": "Default Title", "untranslatedTitle": "Default Title" } }); }, "https://9b9d2f.myshopify.com/cdn", "browser", "0.0.411", "38cecb8bw83165fb4p6f715253m9cc56095", ["web_pixels_async_pixel_refactor", "web_pixels_manager_performance_improvement"]);</script>
  <script>window.ShopifyAnalytics = window.ShopifyAnalytics || {};
    window.ShopifyAnalytics.meta = window.ShopifyAnalytics.meta || {};
    window.ShopifyAnalytics.meta.currency = 'IDR';
    var meta = { "product": { "id": 7814133612699, "gid": "gid:\/\/shopify\/Product\/7814133612699", "vendor": "Slot Gacor 2024", "type": "", "variants": [{ "id": 43910119325851, "price": 0, "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "public_title": null, "sku": "" }] }, "page": { "pageType": "product", "resourceType": "product", "resourceId": 7814133612699 } };
    for (var attr in meta) {
      window.ShopifyAnalytics.meta[attr] = meta[attr];
    }</script>
  <script>window.ShopifyAnalytics.merchantGoogleAnalytics = function () {

    };
  </script>
  <script class="analytics">(function () {
      var customDocumentWrite = function (content) {
        var jquery = null;

        if (window.jQuery) {
          jquery = window.jQuery;
        } else if (window.Checkout && window.Checkout.$) {
          jquery = window.Checkout.$;
        }

        if (jquery) {
          jquery('body').append(content);
        }
      };

      var hasLoggedConversion = function (token) {
        if (token) {
          return document.cookie.indexOf('loggedConversion=' + token) !== -1;
        }
        return false;
      }

      var setCookieIfConversion = function (token) {
        if (token) {
          var twoMonthsFromNow = new Date(Date.now());
          twoMonthsFromNow.setMonth(twoMonthsFromNow.getMonth() + 2);

          document.cookie = 'loggedConversion=' + token + '; expires=' + twoMonthsFromNow;
        }
      }

      var trekkie = window.ShopifyAnalytics.lib = window.trekkie = window.trekkie || [];
      if (trekkie.integrations) {
        return;
      }
      trekkie.methods = [
        'identify',
        'page',
        'ready',
        'track',
        'trackForm',
        'trackLink'
      ];
      trekkie.factory = function (method) {
        return function () {
          var args = Array.prototype.slice.call(arguments);
          args.unshift(method);
          trekkie.push(args);
          return trekkie;
        };
      };
      for (var i = 0; i < trekkie.methods.length; i++) {
        var key = trekkie.methods[i];
        trekkie[key] = trekkie.factory(key);
      }
      trekkie.load = function (config) {
        trekkie.config = config || {};
        trekkie.config.initialDocumentCookie = document.cookie;
        var first = document.getElementsByTagName('script')[0];
        var script = document.createElement('script');
        script.type = 'text/javascript';
        script.onerror = function (e) {
          var scriptFallback = document.createElement('script');
          scriptFallback.type = 'text/javascript';
          scriptFallback.onerror = function (error) {
            var Monorail = {
              produce: function produce(monorailDomain, schemaId, payload) {
                var currentMs = new Date().getTime();
                var event = {
                  schema_id: schemaId,
                  payload: payload,
                  metadata: {
                    event_created_at_ms: currentMs,
                    event_sent_at_ms: currentMs
                  }
                };
                return Monorail.sendRequest("https://" + monorailDomain + "/v1/produce", JSON.stringify(event));
              },
              sendRequest: function sendRequest(endpointUrl, payload) {
                // Try the sendBeacon API
                if (window && window.navigator && typeof window.navigator.sendBeacon === 'function' && typeof window.Blob === 'function' && !Monorail.isIos12()) {
                  var blobData = new window.Blob([payload], {
                    type: 'text/plain'
                  });

                  if (window.navigator.sendBeacon(endpointUrl, blobData)) {
                    return true;
                  } // sendBeacon was not successful

                } // XHR beacon

                var xhr = new XMLHttpRequest();

                try {
                  xhr.open('POST', endpointUrl);
                  xhr.setRequestHeader('Content-Type', 'text/plain');
                  xhr.send(payload);
                } catch (e) {
                  console.log(e);
                }

                return false;
              },
              isIos12: function isIos12() {
                return window.navigator.userAgent.lastIndexOf('iPhone; CPU iPhone OS 12_') !== -1 || window.navigator.userAgent.lastIndexOf('iPad; CPU OS 12_') !== -1;
              }
            };
            Monorail.produce('monorail-edge.shopifysvc.com',
              'trekkie_storefront_load_errors/1.1',
              {
                shop_id: 62108369051,
                theme_id: 132929093787,
                app_name: "storefront",
                context_url: window.location.href,
                source_url: "https://9b9d2f.myshopify.com/cdn/s/trekkie.storefront.7a4225caf9379fe42103e492053220a7195df1ae.min.js"
              });

          };
          scriptFallback.async = true;
          scriptFallback.src = 'https://9b9d2f.myshopify.com/cdn/s/trekkie.storefront.7a4225caf9379fe42103e492053220a7195df1ae.min.js';
          first.parentNode.insertBefore(scriptFallback, first);
        };
        script.async = true;
        script.src = 'https://9b9d2f.myshopify.com/cdn/s/trekkie.storefront.7a4225caf9379fe42103e492053220a7195df1ae.min.js';
        first.parentNode.insertBefore(script, first);
      };
      trekkie.load(
        { "Trekkie": { "appName": "storefront", "development": false, "defaultAttributes": { "shopId": 62108369051, "isMerchantRequest": null, "themeId": 132929093787, "themeCityHash": "1037719678984080351", "contentLanguage": "en", "currency": "IDR" }, "isServerSideCookieWritingEnabled": true, "monorailRegion": "shop_domain" }, "Session Attribution": {}, "S2S": { "facebookCapiEnabled": false, "source": "trekkie-storefront-renderer" } }
      );

      var loaded = false;
      trekkie.ready(function () {
        if (loaded) return;
        loaded = true;

        window.ShopifyAnalytics.lib = window.trekkie;


        var originalDocumentWrite = document.write;
        document.write = customDocumentWrite;
        try { window.ShopifyAnalytics.merchantGoogleAnalytics.call(this); } catch (error) { };
        document.write = originalDocumentWrite;

        window.ShopifyAnalytics.lib.page(null, { "pageType": "product", "resourceType": "product", "resourceId": 7814133612699 });

        var match = window.location.pathname.match(/checkouts\/(.+)\/(thank_you|post_purchase)/)
        var token = match ? match[1] : undefined;
        if (!hasLoggedConversion(token)) {
          setCookieIfConversion(token);
          window.ShopifyAnalytics.lib.track("Viewed Product", { "currency": "IDR", "variantId": 43910119325851, "productId": 7814133612699, "productGid": "gid:\/\/shopify\/Product\/7814133612699", "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "price": "0.00", "sku": "", "brand": "Slot Gacor 2024", "variant": null, "category": "", "nonInteraction": true });
          window.ShopifyAnalytics.lib.track("monorail:\/\/trekkie_storefront_viewed_product\/1.1", { "currency": "IDR", "variantId": 43910119325851, "productId": 7814133612699, "productGid": "gid:\/\/shopify\/Product\/7814133612699", "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin", "price": "0.00", "sku": "", "brand": "Slot Gacor 2024", "variant": null, "category": "", "nonInteraction": true, "referer": "https:\/\/9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor" });
        }
      });


      var eventsListenerScript = document.createElement('script');
      eventsListenerScript.async = true;
      eventsListenerScript.src = "https://9b9d2f.myshopify.com/cdn/shopifycloud/shopify/assets/shop_events_listener-a7c63dba65ccddc484f77541dc8ca437e60e1e9e297fe1c3faebf6523a0ede9b.js";
      document.getElementsByTagName('head')[0].appendChild(eventsListenerScript);

    })();</script>
  <script class="boomerang">
    (function () {
      if (window.BOOMR && (window.BOOMR.version || window.BOOMR.snippetExecuted)) {
        return;
      }
      window.BOOMR = window.BOOMR || {};
      window.BOOMR.snippetStart = new Date().getTime();
      window.BOOMR.snippetExecuted = true;
      window.BOOMR.snippetVersion = 12;
      window.BOOMR.application = "storefront-renderer";
      window.BOOMR.themeName = "Refresh";
      window.BOOMR.themeVersion = "12.0.0";
      window.BOOMR.shopId = 62108369051;
      window.BOOMR.themeId = 132929093787;
      window.BOOMR.renderRegion = "gcp-us-central1";
      window.BOOMR.url =
        "https://9b9d2f.myshopify.com/cdn/shopifycloud/boomerang/shopify-boomerang-1.0.0.min.js";
      var where = document.currentScript || document.getElementsByTagName("script")[0];
      var parentNode = where.parentNode;
      var promoted = false;
      var LOADER_TIMEOUT = 3000;
      function promote() {
        if (promoted) {
          return;
        }
        var script = document.createElement("script");
        script.id = "boomr-scr-as";
        script.src = window.BOOMR.url;
        script.async = true;
        parentNode.appendChild(script);
        promoted = true;
      }
      function iframeLoader(wasFallback) {
        promoted = true;
        var dom, bootstrap, iframe, iframeStyle;
        var doc = document;
        var win = window;
        window.BOOMR.snippetMethod = wasFallback ? "if" : "i";
        bootstrap = function (parent, scriptId) {
          var script = doc.createElement("script");
          script.id = scriptId || "boomr-if-as";
          script.src = window.BOOMR.url;
          BOOMR_lstart = new Date().getTime();
          parent = parent || doc.body;
          parent.appendChild(script);
        };
        if (!window.addEventListener && window.attachEvent && navigator.userAgent.match(/MSIE [67]./)) {
          window.BOOMR.snippetMethod = "s";
          bootstrap(parentNode, "boomr-async");
          return;
        }
        iframe = document.createElement("IFRAME");
        iframe.src = "about:blank";
        iframe.title = "";
        iframe.role = "presentation";
        iframe.loading = "eager";
        iframeStyle = (iframe.frameElement || iframe).style;
        iframeStyle.width = 0;
        iframeStyle.height = 0;
        iframeStyle.border = 0;
        iframeStyle.display = "none";
        parentNode.appendChild(iframe);
        try {
          win = iframe.contentWindow;
          doc = win.document.open();
        } catch (e) {
          dom = document.domain;
          iframe.src = "javascript:var d=document.open();d.domain='" + dom + "';void(0);";
          win = iframe.contentWindow;
          doc = win.document.open();
        }
        if (dom) {
          doc._boomrl = function () {
            this.domain = dom;
            bootstrap();
          };
          doc.write("<body onload='document._boomrl();'>");
        } else {
          win._boomrl = function () {
            bootstrap();
          };
          if (win.addEventListener) {
            win.addEventListener("load", win._boomrl, false);
          } else if (win.attachEvent) {
            win.attachEvent("onload", win._boomrl);
          }
        }
        doc.close();
      }
      var link = document.createElement("link");
      if (link.relList &&
        typeof link.relList.supports === "function" &&
        link.relList.supports("preload") &&
        ("as" in link)) {
        window.BOOMR.snippetMethod = "p";
        link.href = window.BOOMR.url;
        link.rel = "preload";
        link.as = "script";
        link.addEventListener("load", promote);
        link.addEventListener("error", function () {
          iframeLoader(true);
        });
        setTimeout(function () {
          if (!promoted) {
            iframeLoader(true);
          }
        }, LOADER_TIMEOUT);
        BOOMR_lstart = new Date().getTime();
        parentNode.appendChild(link);
      } else {
        iframeLoader(false);
      }
      function boomerangSaveLoadTime(e) {
        window.BOOMR_onload = (e && e.timeStamp) || new Date().getTime();
      }
      if (window.addEventListener) {
        window.addEventListener("load", boomerangSaveLoadTime, false);
      } else if (window.attachEvent) {
        window.attachEvent("onload", boomerangSaveLoadTime);
      }
      if (document.addEventListener) {
        document.addEventListener("onBoomerangLoaded", function (e) {
          e.detail.BOOMR.init({
            ResourceTiming: {
              enabled: true,
              trackedResourceTypes: ["script", "img", "css"]
            },
          });
          e.detail.BOOMR.t_end = new Date().getTime();
        });
      } else if (document.attachEvent) {
        document.attachEvent("onpropertychange", function (e) {
          if (!e) e = event;
          if (e.propertyName === "onBoomerangLoaded") {
            e.detail.BOOMR.init({
              ResourceTiming: {
                enabled: true,
                trackedResourceTypes: ["script", "img", "css"]
              },
            });
            e.detail.BOOMR.t_end = new Date().getTime();
          }
        });
      }
    })();</script>
</head>

<body class="gradient">
  <a class="skip-to-content-link button visually-hidden" href="#MainContent">
    Skip to content
  </a>

  <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/quantity-popover.css?v=153075665213740339621702729580"
    rel="stylesheet" type="text/css" media="all" />
  <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-card.css?v=47260860684073105921702729578"
    rel="stylesheet" type="text/css" media="all" />

  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/cart.js?v=56933888273975671431702729578"
    defer="defer"></script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/quantity-popover.js?v=19455713230017000861702729580"
    defer="defer"></script>

  <style>
    .drawer {
      visibility: hidden;
    }
  </style>

  <cart-drawer class="drawer is-empty">
    <div id="CartDrawer" class="cart-drawer">
      <div id="CartDrawer-Overlay" class="cart-drawer__overlay"></div>
      <div class="drawer__inner gradient color-background-1" role="dialog" aria-modal="true" aria-label="Your cart"
        tabindex="-1">
        <div class="drawer__inner-empty">
          <div class="cart-drawer__warnings center">
            <div class="cart-drawer__empty-content">
              <h2 class="cart__empty-text">Your cart is empty</h2>
              <button class="drawer__close" type="button" onclick="this.closest('cart-drawer').close()"
                aria-label="Close">
                <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" class="icon icon-close"
                  fill="none" viewBox="0 0 18 17">
                  <path
                    d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                    fill="currentColor">
                </svg>

              </button>
              <a href="/collections/all" class="button">
                Continue shopping
              </a>
            </div>
          </div>
        </div>
        <div class="drawer__header">
          <h2 class="drawer__heading">Your cart</h2>
          <button class="drawer__close" type="button" onclick="this.closest('cart-drawer').close()" aria-label="Close">
            <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" class="icon icon-close"
              fill="none" viewBox="0 0 18 17">
              <path
                d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                fill="currentColor">
            </svg>

          </button>
        </div>
        <cart-drawer-items class=" is-empty">
          <form action="/cart" id="CartDrawer-Form" class="cart__contents cart-drawer__form" method="post">
            <div id="CartDrawer-CartItems" class="drawer__contents js-contents">
              <p id="CartDrawer-LiveRegionText" class="visually-hidden" role="status"></p>
              <p id="CartDrawer-LineItemStatus" class="visually-hidden" aria-hidden="true" role="status">
                Loading...
              </p>
            </div>
            <div id="CartDrawer-CartErrors" role="alert"></div>
          </form>
        </cart-drawer-items>
        <div class="drawer__footer"><!-- Start blocks -->
          <!-- Subtotals -->

          <div class="cart-drawer__footer">
            <div></div>

            <div class="totals" role="status">
              <h2 class="totals__total">Estimated total</h2>
              <p class="totals__total-value">Rp 1.000,00 IDR</p>
            </div>

            <small class="tax-note caption-large rte">Taxes, discounts and shipping calculated at checkout
            </small>
          </div>

          <!-- CTAs -->

          <div class="cart__ctas">
            <noscript>
              <button type="submit" class="cart__update-button button button--secondary" form="CartDrawer-Form">
                Update
              </button>
            </noscript>

            <button type="submit" id="CartDrawer-Checkout" class="cart__checkout-button button" name="checkout"
              form="CartDrawer-Form" disabled>
              Check out
            </button>
          </div>
        </div>
      </div>
    </div>
  </cart-drawer>

  <script>
    document.addEventListener('DOMContentLoaded', function () {
      function isIE() {
        const ua = window.navigator.userAgent;
        const msie = ua.indexOf('MSIE ');
        const trident = ua.indexOf('Trident/');

        return msie > 0 || trident > 0;
      }

      if (!isIE()) return;
      const cartSubmitInput = document.createElement('input');
      cartSubmitInput.setAttribute('name', 'checkout');
      cartSubmitInput.setAttribute('type', 'hidden');
      document.querySelector('#cart').appendChild(cartSubmitInput);
      document.querySelector('#checkout').addEventListener('click', function (event) {
        document.querySelector('#cart').submit();
      });
    });
  </script>
  <!-- BEGIN sections: header-group -->
  <div id="shopify-section-sections--16262122963099__header"
    class="shopify-section shopify-section-group-header-group section-header">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-menu.css?v=151968516119678728991702729578"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-search.css?v=165164710990765432851702729579"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-menu-drawer.css?v=31331429079022630271702729579"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-notification.css?v=54116361853792938221702729578"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-items.css?v=145340746371385151771702729578"
      media="print" onload="this.media='all'">
    <link rel="stylesheet"
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-price.css?v=70172745017360139101702729579"
      media="print" onload="this.media='all'">
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-drawer.css?v=11376100058507027511702729578"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart.css?v=181291337967238571831702729578"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-totals.css?v=15906652033866631521702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-price.css?v=70172745017360139101702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-discounts.css?v=152760482443307489271702729578"
      rel="stylesheet" type="text/css" media="all" />
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-menu.css?v=151968516119678728991702729578"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-search.css?v=165164710990765432851702729579"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-menu-drawer.css?v=31331429079022630271702729579"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-notification.css?v=54116361853792938221702729578"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>
    <noscript>
      <link
        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-cart-items.css?v=145340746371385151771702729578"
        rel="stylesheet" type="text/css" media="all" />
    </noscript>

    <style>
      header-drawer {
        justify-self: start;
        margin-left: -1.2rem;
      }

      @media screen and (min-width: 990px) {
        header-drawer {
          display: none;
        }
      }

      .menu-drawer-container {
        display: flex;
      }

      .list-menu {
        list-style: none;
        padding: 0;
        margin: 0;
      }

      .list-menu--inline {
        display: inline-flex;
        flex-wrap: wrap;
      }

      summary.list-menu__item {
        padding-right: 2.7rem;
      }

      .list-menu__item {
        display: flex;
        align-items: center;
        line-height: calc(1 + 0.3 / var(--font-body-scale));
      }

      .list-menu__item--link {
        text-decoration: none;
        padding-bottom: 1rem;
        padding-top: 1rem;
        line-height: calc(1 + 0.8 / var(--font-body-scale));
      }

      @media screen and (min-width: 750px) {
        .list-menu__item--link {
          padding-bottom: 0.5rem;
          padding-top: 0.5rem;
        }
      }
    </style>
    <style data-shopify>
      .header {
        padding: 10px 3rem 10px 3rem;
      }

      .section-header {
        position: sticky;
        /* This is for fixing a Safari z-index issue. PR #2147 */
        margin-bottom: 0px;
      }

      @media screen and (min-width: 750px) {
        .section-header {
          margin-bottom: 0px;
        }
      }

      @media screen and (min-width: 990px) {
        .header {
          padding-top: 20px;
          padding-bottom: 20px;
        }
      }
    </style>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/details-disclosure.js?v=13653116266235556501702729579"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/details-modal.js?v=25581673532751508451702729579"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/cart-notification.js?v=133508293167896966491702729578"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/search-form.js?v=133129549252120666541702729580"
      defer="defer"></script>
    <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/cart-drawer.js?v=105077087914686398511702729578"
      defer="defer"></script><svg xmlns="http://www.w3.org/2000/svg" class="hidden">
      <symbol id="icon-search" viewbox="0 0 18 19" fill="none">
        <path fill-rule="evenodd" clip-rule="evenodd"
          d="M11.03 11.68A5.784 5.784 0 112.85 3.5a5.784 5.784 0 018.18 8.18zm.26 1.12a6.78 6.78 0 11.72-.7l5.4 5.4a.5.5 0 11-.71.7l-5.41-5.4z"
          fill="currentColor" />
      </symbol>

      <symbol id="icon-reset" class="icon icon-close" fill="none" viewBox="0 0 18 18" stroke="currentColor">
        <circle r="8.5" cy="9" cx="9" stroke-opacity="0.2" />
        <path d="M6.82972 6.82915L1.17193 1.17097" stroke-linecap="round" stroke-linejoin="round"
          transform="translate(5 5)" />
        <path d="M1.22896 6.88502L6.77288 1.11523" stroke-linecap="round" stroke-linejoin="round"
          transform="translate(5 5)" />
      </symbol>

      <symbol id="icon-close" class="icon icon-close" fill="none" viewBox="0 0 18 17">
        <path
          d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
          fill="currentColor">
      </symbol>
    </svg>
    <div class="header-wrapper color-inverse gradient">
      <header class="header header--top-center header--mobile-center page-width">

        <details-modal class="header__search">
          <details>
            <summary class="header__icon header__icon--search header__icon--summary link focus-inset modal__toggle"
              aria-haspopup="dialog" aria-label="Search">
              <span>
                <svg class="modal__toggle-open icon icon-search" aria-hidden="true" focusable="false">
                  <use href="#icon-search">
                </svg>
                <svg class="modal__toggle-close icon icon-close" aria-hidden="true" focusable="false">
                  <use href="#icon-close">
                </svg>
              </span>
            </summary>
            <div class="search-modal modal__content gradient" role="dialog" aria-modal="true" aria-label="Search">
              <div class="modal-overlay"></div>
              <div class="search-modal__content search-modal__content-bottom" tabindex="-1"><predictive-search
                  class="search-modal__form" data-loading-text="Loading...">
                  <form action="/search" method="get" role="search" class="search search-modal__form">
                    <div class="field">
                      <input class="search__input field__input" id="Search-In-Modal-1" type="search" name="q" value=""
                        placeholder="Search" role="combobox" aria-expanded="false" aria-owns="predictive-search-results"
                        aria-controls="predictive-search-results" aria-haspopup="listbox" aria-autocomplete="list"
                        autocorrect="off" autocomplete="off" autocapitalize="off" spellcheck="false">
                      <label class="field__label" for="Search-In-Modal-1">Search</label>
                      <input type="hidden" name="options[prefix]" value="last">
                      <button type="reset" class="reset__button field__button hidden" aria-label="Clear search term">
                        <svg class="icon icon-close" aria-hidden="true" focusable="false">
                          <use xlink:href="#icon-reset">
                        </svg>
                      </button>
                      <button class="search__button field__button" aria-label="Search">
                        <svg class="icon icon-search" aria-hidden="true" focusable="false">
                          <use href="#icon-search">
                        </svg>
                      </button>
                    </div>
                    <div class="predictive-search predictive-search--header" tabindex="-1" data-predictive-search>

                      <link
                        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                        rel="stylesheet" type="text/css" media="all" />

                      <div class="predictive-search__loading-state">
                        <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                          xmlns="http://www.w3.org/2000/svg">
                          <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                        </svg>
                      </div>
                    </div>

                    <span class="predictive-search-status visually-hidden" role="status" aria-hidden="true"></span>
                  </form>
                </predictive-search><button type="button"
                  class="search-modal__close-button modal__close-button link link--text focus-inset" aria-label="Close">
                  <svg class="icon icon-close" aria-hidden="true" focusable="false">
                    <use href="#icon-close">
                  </svg>
                </button>
              </div>
            </div>
          </details>
        </details-modal>
        <a href="https://www.elaphye.com/" class="header__heading-link link link--text focus-inset">
          <div class="header__heading-logo-wrapper">

            <img src="//img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=600"
              alt="Slot Gacor 2024"
              srcset="//img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=300 300w, //img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=450 450w, //img.pikachu.pics/slottgacor.png?v=1702729701&amp;width=600 600w"
              width="300" height="58.30078125" loading="eager" class="header__heading-logo motion-reduce"
              sizes="(max-width: 600px) 50vw, 300px">
          </div>
        </a>
        <div class="header__icons header__icons--localization header-localization">
          <div class="desktop-localization-wrapper">
          </div>


          <details-modal class="header__search">
            <details>
              <summary class="header__icon header__icon--search header__icon--summary link focus-inset modal__toggle"
                aria-haspopup="dialog" aria-label="Search">
                <span>
                  <svg class="modal__toggle-open icon icon-search" aria-hidden="true" focusable="false">
                    <use href="#icon-search">
                  </svg>
                  <svg class="modal__toggle-close icon icon-close" aria-hidden="true" focusable="false">
                    <use href="#icon-close">
                  </svg>
                </span>
              </summary>
              <div class="search-modal modal__content gradient" role="dialog" aria-modal="true" aria-label="Search">
                <div class="modal-overlay"></div>
                <div class="search-modal__content search-modal__content-bottom" tabindex="-1"><predictive-search
                    class="search-modal__form" data-loading-text="Loading...">
                    <form action="/search" method="get" role="search" class="search search-modal__form">
                      <div class="field">
                        <input class="search__input field__input" id="Search-In-Modal" type="search" name="q" value=""
                          placeholder="Search" role="combobox" aria-expanded="false"
                          aria-owns="predictive-search-results" aria-controls="predictive-search-results"
                          aria-haspopup="listbox" aria-autocomplete="list" autocorrect="off" autocomplete="off"
                          autocapitalize="off" spellcheck="false">
                        <label class="field__label" for="Search-In-Modal">Search</label>
                        <input type="hidden" name="options[prefix]" value="last">
                        <button type="reset" class="reset__button field__button hidden" aria-label="Clear search term">
                          <svg class="icon icon-close" aria-hidden="true" focusable="false">
                            <use xlink:href="#icon-reset">
                          </svg>
                        </button>
                        <button class="search__button field__button" aria-label="Search">
                          <svg class="icon icon-search" aria-hidden="true" focusable="false">
                            <use href="#icon-search">
                          </svg>
                        </button>
                      </div>
                      <div class="predictive-search predictive-search--header" tabindex="-1" data-predictive-search>

                        <link
                          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                          rel="stylesheet" type="text/css" media="all" />

                        <div class="predictive-search__loading-state">
                          <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                            xmlns="http://www.w3.org/2000/svg">
                            <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                          </svg>
                        </div>
                      </div>

                      <span class="predictive-search-status visually-hidden" role="status" aria-hidden="true"></span>
                    </form>
                  </predictive-search><button type="button"
                    class="search-modal__close-button modal__close-button link link--text focus-inset"
                    aria-label="Close">
                    <svg class="icon icon-close" aria-hidden="true" focusable="false">
                      <use href="#icon-close">
                    </svg>
                  </button>
                </div>
              </div>
            </details>
          </details-modal>

          <a href="https://www.elaphye.com/" class="header__icon header__icon--cart link focus-inset" id="cart-icon-bubble"><svg
              class="icon icon-cart-empty" aria-hidden="true" focusable="false" xmlns="http://www.w3.org/2000/svg"
              viewBox="0 0 40 40" fill="none">
              <path
                d="m15.75 11.8h-3.16l-.77 11.6a5 5 0 0 0 4.99 5.34h7.38a5 5 0 0 0 4.99-5.33l-.78-11.61zm0 1h-2.22l-.71 10.67a4 4 0 0 0 3.99 4.27h7.38a4 4 0 0 0 4-4.27l-.72-10.67h-2.22v.63a4.75 4.75 0 1 1 -9.5 0zm8.5 0h-7.5v.63a3.75 3.75 0 1 0 7.5 0z"
                fill="currentColor" fill-rule="evenodd" />
            </svg>
            <span class="visually-hidden">Cart</span></a>
        </div>
      </header>
    </div>

    <script type="application/ld+json">
  {
    "@context": "http://schema.org",
    "@type": "Organization",
    "name": "Slot Gacor 2024",
    
      "logo": "https:\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/SLOTGACORR.png?v=1702729701\u0026width=500",
    
    "sameAs": [
      "",
      "",
      "",
      "",
      "",
      "",
      "",
      "",
      ""
    ],
    "url": "https:\/\/9b9d2f.myshopify.com"
  }
</script>
  </div>
  <!-- END sections: header-group -->

  <main id="MainContent" class="content-for-layout focus-none" role="main" tabindex="-1">
    <section id="shopify-section-template--16262122635419__main" class="shopify-section section">
      <section id="MainProduct-template--16262122635419__main"
        class="section-template--16262122635419__main-padding gradient color-background-1"
        data-section="template--16262122635419__main">
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/section-main-product.css?v=141059467971401676601702729580"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-accordion.css?v=180964204318874863811702729578"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-price.css?v=70172745017360139101702729579"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-slider.css?v=142503135496229589681702729579"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841702729579"
          rel="stylesheet" type="text/css" media="all" />
        <link
          href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-deferred-media.css?v=14096082462203297471702729578"
          rel="stylesheet" type="text/css" media="all" />
        <style data-shopify>
          .section-template--16262122635419__main-padding {
            padding-top: 45px;
            padding-bottom: 45px;
          }

          @media screen and (min-width: 750px) {
            .section-template--16262122635419__main-padding {
              padding-top: 60px;
              padding-bottom: 60px;
            }
          }
        </style>
        <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/product-info.js?v=81873523020508815201702729580"
          defer="defer"></script>
        <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/product-form.js?v=133081758708377679181702729580"
          defer="defer"></script>

        <div class="page-width">
          <div
            class="product product--small product--left product--thumbnail_slider product--mobile-hide grid grid--1-col grid--2-col-tablet">
            <div class="grid__item product__media-wrapper">

              <media-gallery id="MediaGallery-template--16262122635419__main" role="region"
                class="product__column-sticky" aria-label="Gallery Viewer" data-desktop-layout="thumbnail_slider">
                <div id="GalleryStatus-template--16262122635419__main" class="visually-hidden" role="status"></div>
                <slider-component id="GalleryViewer-template--16262122635419__main" class="slider-mobile-gutter"><a
                    class="skip-to-content-link button visually-hidden quick-add-hidden"
                    href="#ProductInfo-template--16262122635419__main">
                    Skip to product information
                  </a>
                  <ul id="Slider-Gallery-template--16262122635419__main"
                    class="product__media-list contains-media grid grid--peek list-unstyled slider slider--mobile"
                    role="list">
                    <li id="Slide-template--16262122635419__main-28590940422299"
                      class="product__media-item grid__item slider__slide is-active scroll-trigger animate--fade-in"
                      data-media-id="template--16262122635419__main-28590940422299">

                      <div
                        class="product-media-container media-type-image media-fit-contain global-media-settings gradient constrain-height"
                        style="--ratio: 1.0; --preview-ratio: 1.0;">
                        <noscript>
                          <div class="product__media media">
                            <img
                              src="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946"
                              alt=""
                              srcset="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=246 246w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=493 493w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=600 600w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=713 713w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=823 823w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=990 990w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1100 1100w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1206 1206w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1346 1346w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1426 1426w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1646 1646w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946 1946w"
                              width="1946" height="1946"
                              sizes="(min-width: 1200px) 495px, (min-width: 990px) calc(45.0vw - 10rem), (min-width: 750px) calc((100vw - 11.5rem) / 2), calc(100vw / 1 - 4rem)">
                          </div>
                        </noscript>

                        <modal-opener class="product__modal-opener product__modal-opener--image no-js-hidden"
                          data-modal="#ProductModal-template--16262122635419__main">
                          <span class="product__media-icon motion-reduce quick-add-hidden product__media-icon--lightbox"
                            aria-hidden="true"><svg aria-hidden="true" focusable="false" class="icon icon-plus"
                              width="19" height="19" viewBox="0 0 19 19" fill="none" xmlns="http://www.w3.org/2000/svg">
                              <path fill-rule="evenodd" clip-rule="evenodd"
                                d="M4.66724 7.93978C4.66655 7.66364 4.88984 7.43922 5.16598 7.43853L10.6996 7.42464C10.9758 7.42395 11.2002 7.64724 11.2009 7.92339C11.2016 8.19953 10.9783 8.42395 10.7021 8.42464L5.16849 8.43852C4.89235 8.43922 4.66793 8.21592 4.66724 7.93978Z"
                                fill="currentColor" />
                              <path fill-rule="evenodd" clip-rule="evenodd"
                                d="M7.92576 4.66463C8.2019 4.66394 8.42632 4.88723 8.42702 5.16337L8.4409 10.697C8.44159 10.9732 8.2183 11.1976 7.94215 11.1983C7.66601 11.199 7.44159 10.9757 7.4409 10.6995L7.42702 5.16588C7.42633 4.88974 7.64962 4.66532 7.92576 4.66463Z"
                                fill="currentColor" />
                              <path fill-rule="evenodd" clip-rule="evenodd"
                                d="M12.8324 3.03011C10.1255 0.323296 5.73693 0.323296 3.03011 3.03011C0.323296 5.73693 0.323296 10.1256 3.03011 12.8324C5.73693 15.5392 10.1255 15.5392 12.8324 12.8324C15.5392 10.1256 15.5392 5.73693 12.8324 3.03011ZM2.32301 2.32301C5.42035 -0.774336 10.4421 -0.774336 13.5395 2.32301C16.6101 5.39361 16.6366 10.3556 13.619 13.4588L18.2473 18.0871C18.4426 18.2824 18.4426 18.599 18.2473 18.7943C18.0521 18.9895 17.7355 18.9895 17.5402 18.7943L12.8778 14.1318C9.76383 16.6223 5.20839 16.4249 2.32301 13.5395C-0.774335 10.4421 -0.774335 5.42035 2.32301 2.32301Z"
                                fill="currentColor" />
                            </svg>
                          </span>

                          <link
                            href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                            rel="stylesheet" type="text/css" media="all" />

                          <div class="loading__spinner hidden">
                            <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                              xmlns="http://www.w3.org/2000/svg">
                              <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                            </svg>
                          </div>
                          <div class="product__media media media--transparent">
                            <img
                              src="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946"
                              alt=""
                              srcset="//iili.io/JYh9IFp.jpg?v=1702729284&amp;width=246 246w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=493 493w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=600 600w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=713 713w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=823 823w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=990 990w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1100 1100w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1206 1206w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1346 1346w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1426 1426w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1646 1646w, //iili.io/JYh9IFp.jpg?v=1702729284&amp;width=1946 1946w"
                              width="1946" height="1946" class="image-magnify-lightbox"
                              sizes="(min-width: 1200px) 495px, (min-width: 990px) calc(45.0vw - 10rem), (min-width: 750px) calc((100vw - 11.5rem) / 2), calc(100vw / 1 - 4rem)">
                          </div>
                          <button class="product__media-toggle quick-add-hidden product__media-zoom-lightbox"
                            type="button" aria-haspopup="dialog" data-media-id="28590940422299">
                            <span class="visually-hidden">
                              Open media 1 in modal
                            </span>
                          </button>
                        </modal-opener>
                      </div>

                    </li>
                  </ul>
                  <div class="slider-buttons no-js-hidden quick-add-hidden small-hide">
                    <button type="button" class="slider-button slider-button--prev" name="previous"
                      aria-label="Slide left">
                      <svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
                          fill="currentColor">
                      </svg>

                    </button>
                    <div class="slider-counter caption">
                      <span class="slider-counter--current">1</span>
                      <span aria-hidden="true"> / </span>
                      <span class="visually-hidden">of</span>
                      <span class="slider-counter--total">1</span>
                    </div>
                    <button type="button" class="slider-button slider-button--next" name="next"
                      aria-label="Slide right">
                      <svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
                          fill="currentColor">
                      </svg>

                    </button>
                  </div>
                </slider-component>
              </media-gallery>

            </div>
            <div class="product__info-wrapper grid__item scroll-trigger animate--slide-in">
              <product-info id="ProductInfo-template--16262122635419__main"
                data-section="template--16262122635419__main"
                data-url="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor"
                class="product__info-container product__column-sticky">
                <p class="product__text inline-richtext">LINK SLOT MAXWIN</p>
                <div class="product__title">
                  <h1>Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin</h1>
                  <a href="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor" class="product__title">
                    <h2 class="h1">
                      Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin
                    </h2>
                  </a>
                </div>
                <div class="no-js-hidden" id="price-template--16262122635419__main" role="status">
                  <div class="
    price price--large price--sold-out price--show-badge">
                    <div class="price__container">
                      <div class="price__regular"><span class="visually-hidden visually-hidden--inline">Regular
                          price</span>
                        <span class="price-item price-item--regular">
                          Rp 1.000,00
                        </span>
                      </div>
                      <div class="price__sale">
                        <span class="visually-hidden visually-hidden--inline">Regular price</span>
                        <span>
                          <s class="price-item price-item--regular">



                          </s>
                        </span><span class="visually-hidden visually-hidden--inline">Sale price</span>
                        <span class="price-item price-item--sale price-item--last">
                          Rp 1.000,00
                        </span>
                      </div>
                      <small class="unit-price caption hidden">
                        <span class="visually-hidden">Unit price</span>
                        <span class="price-item price-item--last">
                          <span></span>
                          <span aria-hidden="true">/</span>
                          <span class="visually-hidden">&nbsp;per&nbsp;</span>
                          <span>
                          </span>
                        </span>
                      </small>
                    </div><span class="badge price__badge-sale color-accent-1">
                      Sale
                    </span>
                    <br>
                    <span class="badge price__badge-sold-out color-background-1">
                      Slot Maxwin Bre
                    </span>
                  </div>
                </div>
                <div class="product__tax caption rte"></div>
                <div>
                  <form method="post" action="/cart/add" id="product-form-installment-template--16262122635419__main"
                    accept-charset="UTF-8" class="installment caption-large" enctype="multipart/form-data"><input
                      type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8"
                      value="✓" /><input type="hidden" name="id" value="43910119325851">

                    <input type="hidden" name="product-id" value="7814133612699" />
                  </form>
                </div>
                <noscript class="product-form__noscript-wrapper-template--16262122635419__main">
                  <div class="product-form__input hidden">
                    <label class="form__label" for="Variants-template--16262122635419__main">Product variants</label>
                    <div class="select">
                      <select name="id" id="Variants-template--16262122635419__main" class="select__select"
                        form="product-form-template--16262122635419__main">
                        <option selected="selected" disabled value="43910119325851">Default Title - Rp 1.000,00 - Sold out
                        </option>
                      </select>
                      <svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
                          fill="currentColor">
                      </svg>

                    </div>
                  </div>
                </noscript>

                <div id="Quantity-Form-template--16262122635419__main"
                  class="product-form__input product-form__quantity">



                  <label class="quantity__label form__label" for="Quantity-template--16262122635419__main">
                    Quantity
                    <span class="quantity__rules-cart no-js-hidden hidden">

                      <link
                        href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                        rel="stylesheet" type="text/css" media="all" />

                      <div class="loading__spinner hidden">
                        <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                          xmlns="http://www.w3.org/2000/svg">
                          <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                        </svg>
                      </div>
                      <span>(<span class="quantity-cart">0</span> in cart)</span>
                    </span>
                  </label>
                  <div class="price-per-item__container">
                    <quantity-input class="quantity" data-url="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor"
                      data-section="template--16262122635419__main">
                      <button class="quantity__button no-js-hidden" name="minus" type="button">
                        <span class="visually-hidden">Decrease quantity for LINK MAXWIN: Link Slot Maxwin Terpercaya Yang
                          Lagi Gacor Malam Ini 2024</span>
                        <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false"
                          class="icon icon-minus" fill="none" viewBox="0 0 10 2">
                          <path fill-rule="evenodd" clip-rule="evenodd"
                            d="M.5 1C.5.7.7.5 1 .5h8a.5.5 0 110 1H1A.5.5 0 01.5 1z" fill="currentColor">
                        </svg>

                      </button>
                      <input class="quantity__input" type="number" name="quantity"
                        id="Quantity-template--16262122635419__main" data-cart-quantity="0" data-min="1" min="1"
                        step="1" value="1" form="product-form-template--16262122635419__main" />
                      <button class="quantity__button no-js-hidden" name="plus" type="button">
                        <span class="visually-hidden">Increase quantity for LINK MAXWIN: Link Slot Maxwin Terpercaya Yang
                          Lagi Gacor Malam Ini 2024</span>
                        <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false"
                          class="icon icon-plus" fill="none" viewBox="0 0 10 10">
                          <path fill-rule="evenodd" clip-rule="evenodd"
                            d="M1 4.51a.5.5 0 000 1h3.5l.01 3.5a.5.5 0 001-.01V5.5l3.5-.01a.5.5 0 00-.01-1H5.5L5.49.99a.5.5 0 00-1 .01v3.5l-3.5.01H1z"
                            fill="currentColor">
                        </svg>

                      </button>
                    </quantity-input>
                  </div>
                  <div class="quantity__rules caption no-js-hidden" id="Quantity-Rules-template--16262122635419__main">
                  </div>
                </div>
                <div><product-form class="product-form" data-hide-errors="false"
                    data-section-id="template--16262122635419__main">
                    <div class="product-form__error-message-wrapper" role="alert" hidden>
                      <svg aria-hidden="true" focusable="false" class="icon icon-error" viewBox="0 0 13 13">
                        <circle cx="6.5" cy="6.50049" r="5.5" stroke="white" stroke-width="2" />
                        <circle cx="6.5" cy="6.5" r="5.5" fill="#EB001B" stroke="#EB001B" stroke-width="0.7" />
                        <path
                          d="M5.87413 3.52832L5.97439 7.57216H7.02713L7.12739 3.52832H5.87413ZM6.50076 9.66091C6.88091 9.66091 7.18169 9.37267 7.18169 9.00504C7.18169 8.63742 6.88091 8.34917 6.50076 8.34917C6.12061 8.34917 5.81982 8.63742 5.81982 9.00504C5.81982 9.37267 6.12061 9.66091 6.50076 9.66091Z"
                          fill="white" />
                        <path
                          d="M5.87413 3.17832H5.51535L5.52424 3.537L5.6245 7.58083L5.63296 7.92216H5.97439H7.02713H7.36856L7.37702 7.58083L7.47728 3.537L7.48617 3.17832H7.12739H5.87413ZM6.50076 10.0109C7.06121 10.0109 7.5317 9.57872 7.5317 9.00504C7.5317 8.43137 7.06121 7.99918 6.50076 7.99918C5.94031 7.99918 5.46982 8.43137 5.46982 9.00504C5.46982 9.57872 5.94031 10.0109 6.50076 10.0109Z"
                          fill="white" stroke="#EB001B" stroke-width="0.7">
                      </svg>
                      <span class="product-form__error-message"></span>
                    </div>
                    <form method="post" action="/cart/add" id="product-form-template--16262122635419__main"
                      accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate"
                      data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input
                        type="hidden" name="utf8" value="✓" /><input type="hidden" name="id" value="43910119325851"
                        disabled class="product-variant-id">
                      <div class="product-form__buttons"><button id="ProductSubmitButton-template--16262122635419__main"
                          type="submit" name="add"
                          class="product-form__submit button button--full-width button--secondary" disabled>
                          <span>SLOT GACOR MAXWIN
                          </span>

                          <link
                            href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481702729579"
                            rel="stylesheet" type="text/css" media="all" />

                          <div class="loading__spinner hidden">
                            <svg aria-hidden="true" focusable="false" class="spinner" viewBox="0 0 66 66"
                              xmlns="http://www.w3.org/2000/svg">
                              <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
                            </svg>
                          </div>
                        </button>
                        <div data-shopify="payment-button" class="shopify-payment-button"><dynamic-checkout
                            wallet-configs="[]" access-token="fac82d16843ffc3f531984d15a54876d" buyer-country="ID"
                            buyer-locale="en" buyer-currency="IDR" shop-id="62108369051" disabled>
                            <div class="shopify-payment-button__button shopify-payment-button__skeleton" role="button"
                              disabled aria-hidden="true">&nbsp;</div>
                          </dynamic-checkout></div>
                      </div><input type="hidden" name="product-id" value="7814133612699" />
                    </form>
                  </product-form>
                  <link
                    href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-pickup-availability.css?v=34645222959864780961702729579"
                    rel="stylesheet" type="text/css" media="all" />
                  <pickup-availability class="product__pickup-availabilities no-js-hidden quick-add-hidden"
                    data-root-url="/" data-variant-id="43910119325851" data-has-only-default-variant="true"
                    data-product-page-color-scheme="gradient color-background-1">
                    <template>
                      <pickup-availability-preview class="pickup-availability-preview">
                        <svg xmlns="http://www.w3.org/2000/svg" fill="none" aria-hidden="true" focusable="false"
                          class="icon icon-unavailable" fill="none" viewBox="0 0 20 20">
                          <path fill="#DE3618" stroke="#fff"
                            d="M13.94 3.94L10 7.878l-3.94-3.94A1.499 1.499 0 103.94 6.06L7.88 10l-3.94 3.94a1.499 1.499 0 102.12 2.12L10 12.12l3.94 3.94a1.497 1.497 0 002.12 0 1.499 1.499 0 000-2.12L12.122 10l3.94-3.94a1.499 1.499 0 10-2.121-2.12z" />
                        </svg>

                        <div class="pickup-availability-info">
                          <p class="caption-large">Couldn&#39;t load pickup availability</p>
                          <button class="pickup-availability-button link link--text underlined-link">
                            Refresh
                          </button>
                        </div>
                      </pickup-availability-preview>
                    </template>
                  </pickup-availability>

                  <script
                    src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/pickup-availability.js?v=66138958121968076331702729579"
                    defer="defer"></script>
                </div>
                <div class="product__description rte quick-add-hidden">
                  <p><a href="https://xn--12caqc0kdm3if.xn--12cl1fk1e.art/" target="_blank"
                      data-mce-href="https://xn--12caqc0kdm3if.xn--12cl1fk1e.art/"><img height="155" width="310"
                        alt="daftar-sekarang"
                        src="https://cdn.shopify.com/s/files/1/0621/0836/9051/files/datar-sekarang_480x480.gif?v=1702728829"
                        data-mce-src="https://cdn.shopify.com/s/files/1/0621/0836/9051/files/datar-sekarang_480x480.gif?v=1702728829"
                        data-mce-fragment="1"></a></p>
                  <p>Link situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik</p>
                </div>
                <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/share.js?v=13024540447964430191702729580"
                  defer="defer"></script>

                <share-button id="Share-template--16262122635419__main" class="share-button quick-add-hidden">
                  <button class="share-button__button hidden">
                    <svg width="13" height="12" viewBox="0 0 13 12" class="icon icon-share" fill="none"
                      xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false">
                      <path
                        d="M1.625 8.125V10.2917C1.625 10.579 1.73914 10.8545 1.9423 11.0577C2.14547 11.2609 2.42102 11.375 2.70833 11.375H10.2917C10.579 11.375 10.8545 11.2609 11.0577 11.0577C11.2609 10.8545 11.375 10.579 11.375 10.2917V8.125"
                        stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" />
                      <path fill-rule="evenodd" clip-rule="evenodd"
                        d="M6.14775 1.27137C6.34301 1.0761 6.65959 1.0761 6.85485 1.27137L9.56319 3.9797C9.75845 4.17496 9.75845 4.49154 9.56319 4.6868C9.36793 4.88207 9.05135 4.88207 8.85609 4.6868L6.5013 2.33203L4.14652 4.6868C3.95126 4.88207 3.63468 4.88207 3.43942 4.6868C3.24415 4.49154 3.24415 4.17496 3.43942 3.9797L6.14775 1.27137Z"
                        fill="currentColor" />
                      <path fill-rule="evenodd" clip-rule="evenodd"
                        d="M6.5 1.125C6.77614 1.125 7 1.34886 7 1.625V8.125C7 8.40114 6.77614 8.625 6.5 8.625C6.22386 8.625 6 8.40114 6 8.125V1.625C6 1.34886 6.22386 1.125 6.5 1.125Z"
                        fill="currentColor" />
                    </svg>

                    Share
                  </button>
                  <details id="Details-share-template--16262122635419__main">
                    <summary class="share-button__button">
                      <svg width="13" height="12" viewBox="0 0 13 12" class="icon icon-share" fill="none"
                        xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false">
                        <path
                          d="M1.625 8.125V10.2917C1.625 10.579 1.73914 10.8545 1.9423 11.0577C2.14547 11.2609 2.42102 11.375 2.70833 11.375H10.2917C10.579 11.375 10.8545 11.2609 11.0577 11.0577C11.2609 10.8545 11.375 10.579 11.375 10.2917V8.125"
                          stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" />
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M6.14775 1.27137C6.34301 1.0761 6.65959 1.0761 6.85485 1.27137L9.56319 3.9797C9.75845 4.17496 9.75845 4.49154 9.56319 4.6868C9.36793 4.88207 9.05135 4.88207 8.85609 4.6868L6.5013 2.33203L4.14652 4.6868C3.95126 4.88207 3.63468 4.88207 3.43942 4.6868C3.24415 4.49154 3.24415 4.17496 3.43942 3.9797L6.14775 1.27137Z"
                          fill="currentColor" />
                        <path fill-rule="evenodd" clip-rule="evenodd"
                          d="M6.5 1.125C6.77614 1.125 7 1.34886 7 1.625V8.125C7 8.40114 6.77614 8.625 6.5 8.625C6.22386 8.625 6 8.40114 6 8.125V1.625C6 1.34886 6.22386 1.125 6.5 1.125Z"
                          fill="currentColor" />
                      </svg>

                      Share
                    </summary>
                    <div class="share-button__fallback motion-reduce">
                      <div class="field">
                        <span id="ShareMessage-template--16262122635419__main" class="share-button__message hidden"
                          role="status"> </span>
                        <input type="text" class="field__input" id="ShareUrl-template--16262122635419__main"
                          value="https://www.elaphye.com/"
                          placeholder="Link" onclick="this.select();" readonly>
                        <label class="field__label" for="ShareUrl-template--16262122635419__main">Link</label>
                      </div>
                      <button class="share-button__close hidden no-js-hidden">
                        <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false"
                          class="icon icon-close" fill="none" viewBox="0 0 18 17">
                          <path
                            d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                            fill="currentColor">
                        </svg>

                        <span class="visually-hidden">Close share</span>
                      </button>
                      <button class="share-button__copy no-js-hidden">
                        <svg class="icon icon-clipboard" width="11" height="13" fill="none"
                          xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" viewBox="0 0 11 13">
                          <path fill-rule="evenodd" clip-rule="evenodd"
                            d="M2 1a1 1 0 011-1h7a1 1 0 011 1v9a1 1 0 01-1 1V1H2zM1 2a1 1 0 00-1 1v9a1 1 0 001 1h7a1 1 0 001-1V3a1 1 0 00-1-1H1zm0 10V3h7v9H1z"
                            fill="currentColor" />
                        </svg>

                        <span class="visually-hidden">Copy link</span>
                      </button>
                    </div>
                  </details>
                </share-button>

                <a href="/products/link-slot-maxwin-terpercaya-yang-lagi-gacor"
                  class="link product__view-details animate-arrow">
                  View full details
                  <svg viewBox="0 0 14 10" fill="none" aria-hidden="true" focusable="false" class="icon icon-arrow"
                    xmlns="http://www.w3.org/2000/svg">
                    <path fill-rule="evenodd" clip-rule="evenodd"
                      d="M8.537.808a.5.5 0 01.817-.162l4 4a.5.5 0 010 .708l-4 4a.5.5 0 11-.708-.708L11.793 5.5H1a.5.5 0 010-1h10.793L8.646 1.354a.5.5 0 01-.109-.546z"
                      fill="currentColor">
                  </svg>

                </a>
              </product-info>
            </div>
          </div>



          <product-modal id="ProductModal-template--16262122635419__main" class="product-media-modal media-modal">
            <div class="product-media-modal__dialog color-background-1 gradient" role="dialog"
              aria-label="Media gallery" aria-modal="true" tabindex="-1">
              <button id="ModalClose-template--16262122635419__main" type="button" class="product-media-modal__toggle"
                aria-label="Close">
                <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" class="icon icon-close"
                  fill="none" viewBox="0 0 18 17">
                  <path
                    d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z"
                    fill="currentColor">
                </svg>

              </button>

              <div class="product-media-modal__content color-background-1 gradient" role="document"
                aria-label="Media gallery" tabindex="0">
                <img class="global-media-settings global-media-settings--no-shadow"
                  srcset="//iili.io/JYh9IFp.jpg?v=1702729284&width=550 550w,//iili.io/JYh9IFp.jpg?v=1702729284 713w"
                  sizes="(min-width: 750px) calc(100vw - 22rem), 1100px"
                  src="//iili.io/JYh9IFp.jpg?v=1702729284&width=1445"
                  alt="Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin" loading="lazy" width="1100"
                  height="1100" data-media-id="28590940422299">
              </div>
            </div>
          </product-modal>



          <script
            src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/product-modal.js?v=116616134454508949461702729580"
            defer="defer"></script>
          <script
            src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/media-gallery.js?v=96661908581229995091702729579"
            defer="defer"></script>
          <script>
            document.addEventListener('DOMContentLoaded', function () {
              function isIE() {
                const ua = window.navigator.userAgent;
                const msie = ua.indexOf('MSIE ');
                const trident = ua.indexOf('Trident/');

                return msie > 0 || trident > 0;
              }

              if (!isIE()) return;
              const hiddenInput = document.querySelector('#product-form-template--16262122635419__main input[name="id"]');
              const noScriptInputWrapper = document.createElement('div');
              const variantSwitcher =
                document.querySelector('variant-radios[data-section="template--16262122635419__main"]') ||
                document.querySelector('variant-selects[data-section="template--16262122635419__main"]');
              noScriptInputWrapper.innerHTML = document.querySelector(
                '.product-form__noscript-wrapper-template--16262122635419__main'
              ).textContent;
              variantSwitcher.outerHTML = noScriptInputWrapper.outerHTML;

              document.querySelector('#Variants-template--16262122635419__main').addEventListener('change', function (event) {
                hiddenInput.value = event.currentTarget.value;
              });
            });
          </script>
          <script type="application/ld+json">
    {
      "@context": "http://schema.org/",
      "@type": "Product",
      "name": "Situs Slot Gacor 2024 Terpercaya 🤪 Cobain Daftar Dapat Slot Online Maxwin",
      "url": "https:\/\/9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor",
      "image": [
          "https:\/\/9b9d2f.myshopify.com\/cdn\/shop\/files\/slotgacornih.jpg?v=1702729284\u0026width=1920"
        ],
      "description": "\nLink situs slot gacor 2024 terpercaya paling maxwin mudah didapat kan dalam permainan slot online saat ini, segera mainkan dan daftarkan diri anda hanya di situs slot gacor paling terpercaya seluruh permainan game slot terbaik",
      
      "brand": {
        "@type": "Brand",
        "name": "Slot Gacor 2024"
      },
      "offers": [{
            "@type" : "Offer","availability" : "http://schema.org/OutOfStock",
            "price" : 0.0,
            "priceCurrency" : "IDR",
            "url" : "https:\/\/9b9d2f.myshopify.com\/products\/link-slot-maxwin-terpercaya-yang-lagi-gacor?variant=43910119325851"
          }
]
    }
  </script>
        </div>
      </section>


    </section>
  </main>

  <!-- BEGIN sections: footer-group -->
  <section id="shopify-section-sections--16262122930331__newsletter"
    class="shopify-section shopify-section-group-footer-group section">
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-newsletter.css?v=4727253280200485261702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/newsletter-section.css?v=62410470717655853621702729579"
      rel="stylesheet" type="text/css" media="all" />
    <style data-shopify>
      .section-sections--16262122930331__newsletter-padding {
        padding-top: 21px;
        padding-bottom: 0px;
      }

      @media screen and (min-width: 750px) {
        .section-sections--16262122930331__newsletter-padding {
          padding-top: 28px;
          padding-bottom: 0px;
        }
      }
    </style>
    <div class="newsletter center ">
      <div
        class="newsletter__wrapper color-inverse gradient content-container isolate content-container--full-width section-sections--16262122930331__newsletter-padding">
        <h2 class="inline-richtext h1 scroll-trigger animate--slide-in" data-cascade style="--animation-order: 1;">
          SLOT MAXWIN YANG LAGI GACOR NIH BREE🤙
        </h2>
      </div>
    </div>


  </section>
  <div id="shopify-section-sections--16262122930331__footer" class="shopify-section shopify-section-group-footer-group">
    <link href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/section-footer.css?v=125160298726032154631702729580"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-newsletter.css?v=4727253280200485261702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-menu.css?v=151968516119678728991702729578"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-payment.css?v=69253961410771838501702729579"
      rel="stylesheet" type="text/css" media="all" />
    <link
      href="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/component-list-social.css?v=35792976012981934991702729579"
      rel="stylesheet" type="text/css" media="all" />
    <style data-shopify>
      .footer {
        margin-top: 0px;
      }

      .section-sections--16262122930331__footer-padding {
        padding-top: 33px;
        padding-bottom: 45px;
      }

      @media screen and (min-width: 750px) {
        .footer {
          margin-top: 0px;
        }

        .section-sections--16262122930331__footer-padding {
          padding-top: 44px;
          padding-bottom: 60px;
        }
      }
    </style>
    <footer class="footer color-inverse gradient section-sections--16262122930331__footer-padding">
      <div class="footer__content-top page-width">
        <div class="footer-block--newsletter scroll-trigger animate--slide-in" data-cascade></div>
      </div>
      <div class="footer__content-bottom scroll-trigger animate--slide-in" data-cascade>
        <div class="footer__content-bottom-wrapper page-width">
          <div class="footer__column footer__localization isolate"></div>
          <div class="footer__column footer__column--info">
            <div class="footer__payment">
              <span class="visually-hidden">Payment methods</span>
              <ul class="list list-payment" role="list"></ul>
            </div>
          </div>
        </div>
        <div class="footer__content-bottom-wrapper page-width">
          <div class="footer__copyright caption">
            <small class="copyright__content">Hak Cipta &copy; 2024 • </strong></a></small>
            <small class="copyright__content"><a target="_blank" rel="nofollow" href="https://www.elaphye.com/"><strong>Power by Seo Pikachu | 18+</a></small>
          </div>
        </div>
      </div>
    </footer>


  </div>
  <!-- END sections: footer-group -->

  <ul hidden>
    <li id="a11y-refresh-page-message">Choosing a selection results in a full page refresh.</li>
    <li id="a11y-new-window-message">Opens in a new window.</li>
  </ul>

  <script>
    window.shopUrl = 'https://9b9d2f.myshopify.com';
    window.routes = {
      cart_add_url: '/cart/add',
      cart_change_url: '/cart/change',
      cart_update_url: '/cart/update',
      cart_url: '/cart',
      predictive_search_url: '/search/suggest',
    };

    window.cartStrings = {
      error: `There was an error while updating your cart. Please try again.`,
      quantityError: `You can only add [quantity] of this item to your cart.`,
    };

    window.variantStrings = {
      addToCart: `Add to cart`,
      soldOut: `Sold out`,
      unavailable: `Unavailable`,
      unavailable_with_option: `[value] - Unavailable`,
    };

    window.quickOrderListStrings = {
      itemsAdded: `[quantity] items added`,
      itemAdded: `[quantity] item added`,
      itemsRemoved: `[quantity] items removed`,
      itemRemoved: `[quantity] item removed`,
      viewCart: `View cart`,
      each: `[money]/ea`,
    };

    window.accessibilityStrings = {
      imageAvailable: `Image [index] is now available in gallery view`,
      shareSuccess: `Link copied to clipboard`,
      pauseSlideshow: `Pause slideshow`,
      playSlideshow: `Play slideshow`,
      recipientFormExpanded: `Gift card recipient form expanded`,
      recipientFormCollapsed: `Gift card recipient form collapsed`,
    };
  </script>
  <script src="https://9b9d2f.myshopify.com/cdn/shop/t/3/assets/predictive-search.js?v=162273246065392412141702729579"
    defer="defer"></script>
</body>

</html>';

Function Calls

None

Variables

None

Stats

MD5	c32c5e5e134307e0180e473d15660434
Eval Count	0
Decode Time	14104 ms

Find this useful? Enter your email to receive occasional updates for securing PHP code.

PHP Decode

Decoded Output download

Did this file decode correctly?

How would you describe this file?

Original Code

Function Calls

Variables

Stats