<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8">

<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link rel="preconnect" href="https://cdnjs.cloudflare.com">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Free Cybersecurity Risk Assessment | Security Audit Quiz | xSIT Consulting</title>
<meta name="description" content="Take our free 5-minute cybersecurity risk assessment. Get an instant security score, risk level, and personalized recommendations from 26-year cybersecurity veterans.">
<meta property="og:title" content="Free Cybersecurity Risk Assessment | xSIT Consulting">
<meta property="og:type" content="website">
<link rel="canonical" href="https://xsit.consulting/cybersecurity-assessment.html">
<script type="application/ld+json">{"@context":"https://schema.org","@type":"Article","headline":"Free Cybersecurity Risk Assessment — Is Your Business Secure?","author":{"@type":"Organization","name":"xSIT Consulting"}}</script>
<link rel="stylesheet" href="https://unpkg.com/aos@2.3.1/dist/aos.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.0/chart.umd.min.js" defer></script>
<style>
*{margin:0;padding:0;box-sizing:border-box}
:root{--cyan:#00d4ff;--purple:#7c3aed;--red:#ef4444;--green:#10b981;--dark:#050510;--card:#0c0c1e;--border:#18183a;--text:#e8e8ff;--muted:#7070a0}
html{scroll-behavior:smooth}
body{background:var(--dark);color:var(--text);font-family:'Segoe UI',system-ui,sans-serif;min-height:100vh;overflow-x:hidden}
nav{position:fixed;top:0;left:0;right:0;z-index:100;display:flex;align-items:center;justify-content:space-between;padding:1rem 2rem;background:rgba(5,5,16,.93);backdrop-filter:blur(12px);border-bottom:1px solid var(--border)}
.nav-logo{font-size:1.4rem;font-weight:900;color:var(--cyan);text-decoration:none;letter-spacing:2px}
.nav-links{display:flex;gap:1.5rem;list-style:none}
.nav-links a{color:var(--muted);text-decoration:none;font-size:.85rem;transition:.2s}
.nav-links a:hover{color:var(--cyan)}
@media(max-width:640px){.nav-links{display:none}}
.hero{min-height:50vh;display:flex;align-items:center;justify-content:center;text-align:center;padding:8rem 1.5rem 3rem;position:relative;overflow:hidden}
.hero-bg{position:absolute;inset:0;background:radial-gradient(ellipse 80% 60% at 50% 0%,rgba(124,58,237,.22) 0%,transparent 65%)}
.scanline{position:absolute;inset:0;background:repeating-linear-gradient(0deg,transparent,transparent 2px,rgba(0,212,255,.015) 2px,rgba(0,212,255,.015) 4px);animation:scan 8s linear infinite}
@keyframes scan{0%{background-position:0 0}100%{background-position:0 100%}}
.hero-content{position:relative;max-width:800px}
.hero-badge{display:inline-block;padding:.35rem 1rem;background:rgba(239,68,68,.15);border:1px solid rgba(239,68,68,.4);border-radius:999px;font-size:.75rem;letter-spacing:2px;text-transform:uppercase;color:#f87171;margin-bottom:1.5rem}
h1{font-size:clamp(2rem,5vw,3.4rem);font-weight:900;line-height:1.1;margin-bottom:1.5rem;background:linear-gradient(135deg,#fff 0%,var(--cyan) 100%);-webkit-background-clip:text;-webkit-text-fill-color:transparent}
.hero-sub{font-size:1.05rem;color:var(--muted);max-width:580px;margin:0 auto}
.container{max-width:800px;margin:0 auto;padding:0 1.5rem}
section{padding:4rem 0}
.quiz-wrap{background:var(--card);border:1px solid var(--border);border-radius:20px;padding:2.5rem;margin:2rem 0}
.progress-bar-wrap{margin-bottom:2rem}
.progress-label{display:flex;justify-content:space-between;font-size:.8rem;color:var(--muted);margin-bottom:.5rem}
.progress-track{height:6px;background:#18183a;border-radius:3px;overflow:hidden}
.progress-fill{height:100%;background:linear-gradient(90deg,var(--purple),var(--cyan));border-radius:3px;transition:.4s}
.question-num{font-size:.75rem;text-transform:uppercase;letter-spacing:2px;color:var(--purple);margin-bottom:.5rem}
.question-text{font-size:1.2rem;font-weight:700;margin-bottom:1.5rem;line-height:1.4}
.answer-opts{display:grid;gap:.75rem}
.ans-btn{background:#0a0a20;border:1px solid var(--border);border-radius:10px;padding:1rem 1.25rem;color:var(--text);font-size:.95rem;cursor:pointer;text-align:left;transition:.25s;display:flex;align-items:center;gap:.75rem}
.ans-btn:hover{border-color:var(--cyan);background:rgba(0,212,255,.06);color:var(--cyan)}
.ans-btn.selected-yes{border-color:var(--green);background:rgba(16,185,129,.08);color:#34d399}
.ans-btn.selected-no{border-color:var(--red);background:rgba(239,68,68,.08);color:#f87171}
.ans-btn.selected-unsure{border-color:#f59e0b;background:rgba(245,158,11,.08);color:#fbbf24}
.ans-icon{font-size:1.1rem;min-width:1.5rem}
.quiz-nav{display:flex;justify-content:space-between;align-items:center;margin-top:2rem}
.nav-btn{padding:.75rem 1.75rem;border-radius:8px;font-weight:700;cursor:pointer;transition:.2s;font-size:.9rem;border:none}
.btn-back{background:transparent;border:1px solid var(--border);color:var(--muted)}
.btn-back:hover{border-color:var(--cyan);color:var(--cyan)}
.btn-next{background:linear-gradient(135deg,var(--purple),var(--cyan));color:#fff}
.btn-next:hover{transform:translateY(-1px);box-shadow:0 6px 18px rgba(124,58,237,.4)}
.btn-next:disabled{opacity:.4;cursor:not-allowed;transform:none;box-shadow:none}
.results-section{display:none;padding:2.5rem;background:var(--card);border:1px solid var(--border);border-radius:20px;margin:2rem 0}
.results-section.show{display:block}
.results-section h2{font-size:1.5rem;margin-bottom:1.5rem;text-align:center}
.score-display{text-align:center;margin-bottom:2rem}
.score-num{font-size:5rem;font-weight:900;line-height:1}
.score-label{font-size:1rem;color:var(--muted);margin-top:.5rem}
.risk-badge{display:inline-block;padding:.5rem 1.5rem;border-radius:999px;font-weight:700;font-size:1rem;letter-spacing:1px;margin-top:.75rem}
.risk-critical{background:rgba(239,68,68,.2);color:#f87171;border:2px solid rgba(239,68,68,.5)}
.risk-high{background:rgba(251,146,60,.2);color:#fb923c;border:2px solid rgba(251,146,60,.5)}
.risk-medium{background:rgba(251,191,36,.2);color:#fbbf24;border:2px solid rgba(251,191,36,.5)}
.risk-low{background:rgba(16,185,129,.2);color:#34d399;border:2px solid rgba(16,185,129,.5)}
.chart-wrap{height:220px;margin:1.5rem auto;max-width:300px}
.recs-list{margin-top:1.5rem}
.rec-item{background:#0a0a20;border-radius:10px;padding:1rem 1.25rem;margin-bottom:.75rem;display:flex;gap:.75rem;align-items:start}
.rec-icon{font-size:1.1rem;min-width:1.5rem;padding-top:.1rem}
.rec-text .rec-title{font-weight:700;font-size:.9rem;margin-bottom:.2rem}
.rec-text .rec-desc{font-size:.82rem;color:var(--muted);line-height:1.5}
.cta-inline{text-align:center;margin-top:2rem;padding:1.5rem;background:rgba(124,58,237,.08);border:1px solid rgba(124,58,237,.25);border-radius:12px}
.cta-inline h3{font-size:1.2rem;margin-bottom:.5rem}
.cta-inline p{font-size:.88rem;color:var(--muted);margin-bottom:1rem}
.btn-cta{display:inline-block;padding:.875rem 2rem;background:linear-gradient(135deg,var(--purple),var(--cyan));border-radius:10px;color:#fff;font-weight:700;text-decoration:none;transition:.3s}
.btn-cta:hover{transform:translateY(-2px);box-shadow:0 8px 24px rgba(124,58,237,.4)}
.trust-strip{display:flex;align-items:center;justify-content:center;gap:2.5rem;flex-wrap:wrap;padding:2rem;background:var(--card);border:1px solid var(--border);border-radius:16px;margin:3rem 0}
.trust-item{text-align:center}
.trust-item .ti-num{font-size:1.4rem;font-weight:900;color:var(--cyan)}
.trust-item .ti-lbl{font-size:.7rem;text-transform:uppercase;letter-spacing:1px;color:var(--muted)}
.cta-section{text-align:center;padding:6rem 1.5rem;background:radial-gradient(ellipse 80% 100% at 50% 50%,rgba(124,58,237,.15) 0%,transparent 70%)}
.cta-section h2{font-size:clamp(1.8rem,4vw,3rem);font-weight:900;margin-bottom:1rem;background:linear-gradient(135deg,#fff,var(--cyan));-webkit-background-clip:text;-webkit-text-fill-color:transparent}
.cta-section p{color:var(--muted);max-width:500px;margin:0 auto 2rem}
.btn-primary{display:inline-block;padding:1rem 2.5rem;background:linear-gradient(135deg,var(--purple),var(--cyan));border-radius:10px;color:#fff;font-weight:700;text-decoration:none;transition:.3s;margin:.5rem}
.btn-primary:hover{transform:translateY(-3px);box-shadow:0 12px 30px rgba(124,58,237,.5)}
.btn-secondary{display:inline-block;padding:1rem 2.5rem;border:1px solid var(--cyan);border-radius:10px;color:var(--cyan);font-weight:700;text-decoration:none;transition:.3s;margin:.5rem}
footer{background:#030308;border-top:1px solid var(--border);padding:3rem 2rem 2rem;text-align:center}
.footer-nav{display:flex;gap:1.5rem;justify-content:center;flex-wrap:wrap;margin-bottom:1.5rem}
.footer-nav a{color:var(--muted);text-decoration:none;font-size:.85rem;transition:.2s}
.footer-nav a:hover{color:var(--cyan)}
footer p{color:var(--muted);font-size:.8rem}
</style>
</head>
<body>
<nav>
  <a href="https://xsit.consulting" class="nav-logo">xSIT</a>
  <ul class="nav-links">
    <li><a href="https://xsit.consulting/cybersecurity.html">Cybersecurity</a></li>
    <li><a href="https://xsit.consulting/managed-it-services.html">Managed IT</a></li>
    <li><a href="https://xsit.consulting/cloud-migration.html">Cloud</a></li>
    <li><a href="https://xsit.consulting/about.html">About</a></li>
  </ul>
</nav>

<section class="hero">
  <div class="hero-bg"></div>
  <div class="scanline"></div>
  <div class="hero-content">
    <div class="hero-badge">🛡 Free Security Assessment</div>
    <h1>Is Your Business Secure? Take the Free 5-Minute Assessment</h1>
    <p class="hero-sub">Answer 10 questions. Get an instant security score, risk rating, and personalized recommendations from OEF veterans with 26+ years in cybersecurity.</p>
  </div>
</section>

<div class="container">
  <div class="quiz-wrap" id="quizWrap" data-aos="fade-up">
    <div class="progress-bar-wrap">
      <div class="progress-label"><span id="prog-text">Question 1 of 10</span><span id="prog-pct">0%</span></div>
      <div class="progress-track"><div class="progress-fill" id="progFill" style="width:0%"></div></div>
    </div>
    <div id="questionArea"></div>
    <div class="quiz-nav">
      <button class="nav-btn btn-back" id="backBtn" onclick="prevQ()" style="display:none">Back</button>
      <div></div>
      <button class="nav-btn btn-next" id="nextBtn" onclick="nextQ()" disabled>Next</button>
    </div>
  </div>

  <div class="results-section" id="resultsSection" data-aos="fade-up">
    <h2>Your Security Assessment Results</h2>
    <div class="score-display">
      <div class="score-num" id="scoreNum">--</div>
      <div class="score-label">Security Score (out of 100)</div>
      <div id="riskBadge"></div>
    </div>
    <div class="chart-wrap"><canvas id="gaugeChart"></canvas></div>
    <div class="recs-list" id="recsList"></div>
    <div class="cta-inline">
      <h3>Want Your Full Audit Report?</h3>
      <p>Our cybersecurity experts will deliver a comprehensive penetration test, vulnerability scan, and remediation roadmap — typically valued at $15,000+.</p>
      <a href="https://xsit.consulting/cybersecurity.html" class="btn-cta">Get Your Full Security Audit</a>
    </div>
  </div>

  <div class="trust-strip" data-aos="fade-up">
    <div class="trust-item"><div class="ti-num">26+</div><div class="ti-lbl">Years Experience</div></div>
    <div class="trust-item"><div class="ti-num">OEF</div><div class="ti-lbl">Combat Veteran</div></div>
    <div class="trust-item"><div class="ti-num">Microsoft</div><div class="ti-lbl">Alumni</div></div>
    <div class="trust-item"><div class="ti-num">Disney</div><div class="ti-lbl">Alumni</div></div>
  </div>
</div>

<section class="cta-section" data-aos="fade-up">
  <h2>Know Your Exposure. Fix It Fast.</h2>
  
<div class="footer-seo-links" style="margin:1.5em 0;text-align:center;">
  <p style="font-size:0.8em;text-transform:uppercase;letter-spacing:1px;opacity:0.7;margin-bottom:0.6em;">Industries &amp; Services</p>
  <ul style="list-style:none;padding:0;margin:0;display:flex;flex-wrap:wrap;justify-content:center;gap:0.4em 1.2em;font-size:0.82em;">
    <li><a href="/it-support-houston-law-firms.html">IT Support for Law Firms</a></li>
    <li><a href="/managed-it-houston-construction.html">Managed IT for Construction</a></li>
    <li><a href="/microsoft-365-migration-houston.html">Microsoft 365 Migration</a></li>
    <li><a href="/it-support-houston-hotels-hospitality.html">IT Support for Hotels &amp; Hospitality</a></li>
    <li><a href="/ransomware-recovery-houston.html">Ransomware Recovery</a></li>
    <li><a href="/voip-unified-communications-houston.html">VoIP &amp; Unified Communications</a></li>
    <li><a href="/it-outsourcing-houston-small-business.html">IT Outsourcing for Small Business</a></li>
    <li><a href="/endpoint-security-houston-businesses.html">Endpoint Security</a></li>
    <li><a href="/it-support-houston-cpa-accounting-firms.html">IT Support for CPA &amp; Accounting Firms</a></li>
    <li><a href="/backup-disaster-recovery-houston-smb.html">Backup &amp; Disaster Recovery</a></li>
    <li><a href="/it-support-houston-medical-practices.html">IT Support for Medical Practices</a></li>
    <li><a href="/cloud-migration-houston-businesses.html">Cloud Migration Houston</a></li>
    <li><a href="/network-security-houston-small-business.html">Network Security</a></li>
    <li><a href="/it-support-houston-real-estate.html">IT Support for Real Estate</a></li>
    <li><a href="/cybersecurity-compliance-houston.html">Cybersecurity Compliance</a></li>
    <li><a href="/it-support-houston-nonprofits.html">IT Support for Nonprofits</a></li>
    <li><a href="/dark-web-monitoring-houston.html">Dark Web Monitoring</a></li>
    <li><a href="/it-support-houston-dental-offices.html">IT Support for Dental Offices</a></li>
    <li><a href="/zero-trust-security-houston.html">Zero Trust Security</a></li>
    <li><a href="/it-support-houston-energy-oil-gas.html">IT Support for Energy &amp; Oil Gas</a></li>
  </ul>
</div>
<p>xSIT's Veteran Family Founded and Operated cybersecurity team delivers enterprise-grade protection at SMB pricing.</p>
  <a href="https://xsit.consulting/cybersecurity.html" class="btn-primary">Get a Free Security Consultation</a>
  <a href="mailto:info@xsit.consulting?subject=Cybersecurity Assessment Request" class="btn-secondary">Email Us Directly</a>
</section>

<footer>
  <nav class="footer-nav">
    <a href="https://xsit.consulting">Home</a>
    <a href="https://xsit.consulting/cybersecurity.html">Cybersecurity</a>
    <a href="https://xsit.consulting/managed-it-services.html">Managed IT</a>
    <a href="https://xsit.consulting/cloud-migration.html">Cloud Migration</a>
    <a href="https://xsit.consulting/it-staff-augmentation.html">IT Staffing</a>
    <a href="https://xsit.consulting/military-veterans.html">Veterans</a>
    <a href="https://xsit.consulting/about.html">About</a>
  </nav>
  <p>xS&trade; IT Consulting | (832) 304-9748 | &copy; Copyright 2026 | All Rights Reserved | Veteran Family Founded and Operated</p>
</footer>

<script src="https://unpkg.com/aos@2.3.1/dist/aos.js"></script>
<script>
AOS.init({duration:700,once:true,offset:60});
const questions=[
  {q:"Do you enforce Multi-Factor Authentication (MFA) for all users?",yes:12,no:-15,unsure:-8,rec:{no:"Enable MFA immediately — it blocks 99.9% of automated attacks. Microsoft Authenticator or Duo are enterprise-grade options.",unsure:"Audit your MFA coverage. Partial MFA deployment leaves gaps attackers actively exploit."}},
  {q:"Are all systems and software patched within 30 days of a security update?",yes:10,no:-14,unsure:-7,rec:{no:"Unpatched systems are the #1 attack vector. Implement automated patch management (WSUS, Intune, or a managed service).",unsure:"Establish a documented patch cadence. Unknown patch status is nearly as risky as no patching."}},
  {q:"Do employees receive regular cybersecurity awareness training?",yes:8,no:-10,unsure:-5,rec:{no:"85% of breaches involve a human element. Quarterly phishing simulations and security training reduce risk dramatically.",unsure:"Assess your current training coverage. Annual-only training is insufficient against modern phishing tactics."}},
  {q:"Do you maintain encrypted, tested backups stored off-site or in the cloud?",yes:10,no:-14,unsure:-7,rec:{no:"Without tested backups, ransomware is company-ending. Implement 3-2-1 backup strategy immediately.",unsure:"Test your backup restoration process. Untested backups frequently fail when you need them most."}},
  {q:"Do you have a documented Incident Response Plan (IRP)?",yes:8,no:-10,unsure:-6,rec:{no:"Organizations without an IRP face 38% higher breach costs. xSIT can build your IRP in 2 weeks.",unsure:"Review and formalize any informal response procedures. Documentation is critical under regulatory scrutiny."}},
  {q:"Do you use endpoint detection and response (EDR) / next-gen antivirus on all devices?",yes:10,no:-13,unsure:-6,rec:{no:"Traditional antivirus misses 45% of modern attacks. EDR solutions like CrowdStrike or SentinelOne provide real-time threat hunting.",unsure:"Audit your endpoint coverage. Shadow devices and BYOD are common blind spots."}},
  {q:"Do you assess cybersecurity risks of your third-party vendors?",yes:8,no:-10,unsure:-5,rec:{no:"60% of breaches originate from third parties. Implement a vendor risk questionnaire and security review process.",unsure:"Formalize your vendor assessment process. Informal trust relationships are a compliance and legal risk."}},
  {q:"Do you enforce least-privilege access controls (users only have the access they need)?",yes:8,no:-10,unsure:-5,rec:{no:"Over-privileged accounts dramatically amplify breach impact. Implement RBAC and audit all admin accounts immediately.",unsure:"Conduct an access rights review. Privilege creep is endemic in most organizations."}},
  {q:"Is sensitive data encrypted at rest and in transit?",yes:9,no:-12,unsure:-6,rec:{no:"Unencrypted data turns a breach into a notification nightmare. Implement TLS 1.2+ and AES-256 at-rest encryption.",unsure:"Classify your data and map encryption coverage. Many organizations have encryption gaps they're unaware of."}},
  {q:"Do you have a network firewall and monitor network traffic for anomalies?",yes:8,no:-11,unsure:-5,rec:{no:"A perimeter firewall alone is insufficient — you need SIEM or MDR for behavioral detection inside your network.",unsure:"Review your firewall rules and logging. Stale rules and unmonitored logs are common in SMB environments."}}
];

let current=0, answers=new Array(questions.length).fill(null);
let gaugeChart=null;

function renderQ(){
  const q=questions[current];
  document.getElementById('prog-text').textContent='Question '+(current+1)+' of '+questions.length;
  const pct=Math.round((current/questions.length)*100);
  document.getElementById('prog-pct').textContent=pct+'%';
  document.getElementById('progFill').style.width=pct+'%';
  document.getElementById('backBtn').style.display=current>0?'':'none';
  document.getElementById('nextBtn').textContent=current===questions.length-1?'See My Results':'Next';
  document.getElementById('nextBtn').disabled=answers[current]===null;
  const sel=answers[current];
  document.getElementById('questionArea').innerHTML='<div class="question-num">Question '+(current+1)+'</div><div class="question-text">'+q.q+'</div><div class="answer-opts"><button class="ans-btn '+(sel==='yes'?'selected-yes':'')+'" onclick="answer(\'yes\')"><span class="ans-icon">&#x2705;</span> Yes — we do this</button><button class="ans-btn '+(sel==='no'?'selected-no':'')+'" onclick="answer(\'no\')"><span class="ans-icon">&#x274C;</span> No — we do not</button><button class="ans-btn '+(sel==='unsure'?'selected-unsure':'')+'" onclick="answer(\'unsure\')"><span class="ans-icon">&#x1F937;</span> Unsure / Partial</button></div>';
}

function answer(val){answers[current]=val;renderQ();document.getElementById('nextBtn').disabled=false;}
function nextQ(){if(current<questions.length-1){current++;renderQ();}else showResults();}
function prevQ(){if(current>0){current--;renderQ();}}

function showResults(){
  let score=50;
  answers.forEach(function(a,i){
    const q=questions[i];
    if(a==='yes')score+=q.yes;
    else if(a==='no')score+=q.no;
    else if(a==='unsure')score+=q.unsure;
  });
  score=Math.max(5,Math.min(100,score));
  document.getElementById('quizWrap').style.display='none';
  const rs=document.getElementById('resultsSection');
  rs.classList.add('show');
  const scoreEl=document.getElementById('scoreNum');
  scoreEl.textContent=score;
  scoreEl.style.color=score>=70?'#34d399':score>=45?'#fbbf24':'#f87171';
  let riskLabel,riskClass;
  if(score>=80){riskLabel='LOW RISK';riskClass='risk-low';}
  else if(score>=60){riskLabel='MEDIUM RISK';riskClass='risk-medium';}
  else if(score>=40){riskLabel='HIGH RISK';riskClass='risk-high';}
  else{riskLabel='CRITICAL RISK';riskClass='risk-critical';}
  document.getElementById('riskBadge').innerHTML='<div class="risk-badge '+riskClass+'">'+riskLabel+'</div>';
  if(gaugeChart)gaugeChart.destroy();
  const ctx=document.getElementById('gaugeChart').getContext('2d');
  gaugeChart=new Chart(ctx,{type:'doughnut',data:{datasets:[{data:[score,100-score],backgroundColor:[score>=70?'rgba(16,185,129,.8)':score>=45?'rgba(251,191,36,.8)':'rgba(239,68,68,.8)','rgba(30,30,60,.5)'],borderWidth:0}]},options:{cutout:'78%',plugins:{legend:{display:false}},rotation:-90,circumference:180}});
  const recs=[];
  answers.forEach(function(a,i){if(a!=='yes'&&questions[i].rec[a]){recs.push({icon:a==='no'?'&#x1F6A8;':'&#x26A0;',text:questions[i].rec[a]});}});
  const recsEl=document.getElementById('recsList');
  if(recs.length===0){recsEl.innerHTML='<div class="rec-item"><span class="rec-icon">&#x1F3C6;</span><div class="rec-text"><div class="rec-title">Excellent security posture!</div><div class="rec-desc">Your organization demonstrates strong security practices. xSIT recommends a professional penetration test to validate your defenses against real-world attack techniques.</div></div></div>';}
  else{recsEl.innerHTML='<h3 style="margin-bottom:1rem;font-size:1rem;color:var(--muted);text-transform:uppercase;letter-spacing:1px">Priority Recommendations</h3>'+recs.slice(0,5).map(function(r){return'<div class="rec-item"><span class="rec-icon">'+r.icon+'</span><div class="rec-text"><div class="rec-desc">'+r.text+'</div></div></div>';}).join('');}
  rs.scrollIntoView({behavior:'smooth',block:'start'});
}
renderQ();
</script>
</body>
</html>

