<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<meta name="theme-color" content="#0d1424">
<title>Prime One Store Manager Guide</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
<style>
:root{
  --navy-950:#070b14; --navy-900:#0d1424; --navy-800:#141d31; --navy-700:#1a2742;
  --blue:#3b8cff; --blue-soft:#8fb8ff; --line:rgba(255,255,255,.11);
  --text:#ffffff; --muted:#c2c9d6; --ok:#34d399; --bad:#f87171;
  --card:rgba(255,255,255,.05); --card-hi:rgba(59,140,255,.16);
  --radius:16px; --ease:cubic-bezier(.22,.8,.24,1);
}
*{box-sizing:border-box;-webkit-tap-highlight-color:transparent}
html,body{margin:0;height:100%;background:var(--navy-950);color:var(--text);
  font-family:Inter,system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;overflow:hidden}
body{background:radial-gradient(120% 70% at 80% 0%,var(--navy-700),var(--navy-900) 50%,var(--navy-950));}
button{font:inherit;color:inherit;background:none;border:0;cursor:pointer}
.app{position:fixed;inset:0;display:flex;flex-direction:column;max-width:560px;margin:0 auto}

/* top bar */
.top{display:flex;align-items:center;gap:12px;padding:calc(10px + env(safe-area-inset-top)) 16px 10px}
.top img{height:30px;width:auto}
.top .crumb{flex:1;min-width:0;font-size:13px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.iconbtn{width:42px;height:42px;border-radius:12px;display:grid;place-items:center;background:var(--card);border:1px solid var(--line)}
.iconbtn svg{width:20px;height:20px}
.progress{height:4px;margin:0 16px;background:rgba(255,255,255,.08);border-radius:4px;overflow:hidden}
.progress i{display:block;height:100%;width:0;background:linear-gradient(90deg,var(--blue),var(--blue-soft));border-radius:4px;transition:width .5s var(--ease)}

/* stage */
.stage{position:relative;flex:1;overflow:hidden}
.track{position:absolute;inset:0;display:flex;transition:transform .45s var(--ease);will-change:transform}
.screen{position:relative;flex:0 0 100%;height:100%;overflow-y:auto;overscroll-behavior:contain;padding:22px 16px 28px;-webkit-overflow-scrolling:touch}
.screen>.in{opacity:0;transform:translateY(14px);transition:opacity .5s var(--ease) .1s,transform .5s var(--ease) .1s}
.screen.active>.in{opacity:1;transform:none}

/* cover */
.cover{position:relative;z-index:1;display:flex;flex-direction:column;align-items:center;justify-content:flex-end;padding-bottom:8px;text-align:center;min-height:100%}
.cover img{width:92px;height:auto;margin-bottom:18px;filter:drop-shadow(0 10px 30px rgba(59,140,255,.35))}
.cover .rule{width:80px;height:2px;background:var(--blue);margin:0 auto 18px;border-radius:2px}
.cover h1{font-size:34px;line-height:1.1;font-weight:800;margin:0 0 10px;letter-spacing:-.02em}
.cover p{color:var(--blue-soft);margin:0 0 30px;font-size:16px}
.cover .meta{color:var(--muted);font-size:13px;margin-top:18px}
.btn{display:inline-flex;align-items:center;justify-content:center;gap:8px;height:52px;padding:0 26px;border-radius:14px;
  font-weight:700;font-size:16px;background:var(--blue);color:#fff;box-shadow:0 8px 24px rgba(59,140,255,.35);transition:transform .15s}
.btn:active{transform:scale(.97)}
.btn.ghost{background:var(--card);box-shadow:none;border:1px solid var(--line)}
.btn.wide{width:100%}

/* photos */
.cover-bg{position:absolute;inset:0;background:#0d1424 60% 0%/cover no-repeat;opacity:0;transition:opacity .8s}
.cover-bg.loaded{opacity:1}
.cover-bg::after{content:"";position:absolute;inset:0;background:linear-gradient(180deg,rgba(7,11,20,.1) 0%,rgba(7,11,20,.25) 35%,rgba(7,11,20,.88) 58%,rgba(7,11,20,.98) 100%)}
.hero{position:relative;margin:-22px -16px 18px;height:clamp(260px,38vh,330px);background:#141d31;display:flex;align-items:flex-end;overflow:hidden}
.hero .ph{position:absolute;inset:0;background:center/cover no-repeat;opacity:0;transform:scale(1.03);transform-origin:center top;transition:opacity .7s,transform 6s ease-out}
.hero .ph.loaded{opacity:1;transform:scale(1)}
.hero::after{content:"";position:absolute;inset:0;background:linear-gradient(180deg,rgba(7,11,20,0) 25%,rgba(7,11,20,.55) 60%,rgba(13,20,36,1) 100%)}
.hero-in{position:relative;z-index:1;padding:0 16px 4px;width:100%}
.hero.tall{height:auto;display:block;background:none;overflow:visible}
.hero.tall::after{display:none}
.hero.tall .ph{position:relative;inset:auto;width:100%;max-height:66vh;background-color:#141d31;transform:none}
.hero.tall .ph::after{content:"";position:absolute;inset:0;background:linear-gradient(180deg,rgba(13,20,36,0) 72%,rgba(13,20,36,1) 100%)}
.hero.tall .hero-in{padding:6px 16px 0}
.hero.tall h2{text-shadow:none}
.hero h2{margin:10px 0 0;text-shadow:0 2px 12px rgba(0,0,0,.5)}
.hero .kicker{color:#fff;text-shadow:0 1px 6px rgba(0,0,0,.6)}
.hero .kicker .num{background:var(--blue)}

/* chapter */
.kicker{display:flex;align-items:center;gap:10px;color:var(--blue-soft);font-size:12px;font-weight:700;letter-spacing:.12em;text-transform:uppercase}
.kicker .num{width:28px;height:28px;border-radius:8px;background:var(--card-hi);display:grid;place-items:center;color:#fff;font-size:13px;letter-spacing:0}
h2{font-size:32px;line-height:1.08;font-weight:800;letter-spacing:-.02em;margin:12px 0 8px}
.lede{color:#d6e2f7;font-size:19px;line-height:1.45;margin:4px 0 22px;font-weight:500}
.items{display:flex;flex-direction:column;gap:10px;margin:0;padding:0;list-style:none}
.item{display:flex;gap:14px;align-items:flex-start;padding:14px 14px;border-radius:var(--radius);background:var(--card);border:1px solid var(--line);
  text-align:left;width:100%;font-size:16px;line-height:1.4;transition:background .25s,border-color .25s,transform .15s}
.item:active{transform:scale(.99)}
.item .mark{flex:0 0 28px;height:28px;border-radius:50%;border:2px solid var(--blue);display:grid;place-items:center;margin-top:-2px;transition:background .25s}
.item .mark svg{width:14px;height:14px;opacity:0;transform:scale(.4);transition:all .25s var(--ease)}
.item.done{background:var(--card-hi);border-color:rgba(59,140,255,.5)}
.item.done .mark{background:var(--blue)}
.item.done .mark svg{opacity:1;transform:none}
.item .stepn{flex:0 0 32px;height:32px;border-radius:50%;border:2px solid var(--blue);display:grid;place-items:center;font-weight:700;color:var(--blue-soft);margin-top:-4px}
.item.done .stepn{background:var(--blue);color:#fff}
.hint{font-size:12.5px;color:var(--muted);margin:10px 2px 0;opacity:.85}
.ask{margin-top:16px;padding:16px;border-radius:var(--radius);border:1px dashed rgba(143,184,255,.4)}
.ask h3{margin:0 0 10px;font-size:13px;text-transform:uppercase;letter-spacing:.12em;color:var(--blue-soft)}
.ask ul{margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:8px}
.ask li{display:flex;gap:10px;font-size:16px;line-height:1.4}
.ask li::before{content:"?";flex:0 0 22px;height:22px;border-radius:50%;background:var(--card-hi);color:var(--blue-soft);font-weight:800;font-size:13px;display:grid;place-items:center}
.callout{margin-top:18px;padding:18px 18px;border-left:4px solid var(--blue);background:linear-gradient(90deg,rgba(59,140,255,.18),rgba(59,140,255,.02));
  border-radius:0 var(--radius) var(--radius) 0;font-size:18px;font-weight:700;line-height:1.35}

/* quiz */
.quiz{margin-top:26px;padding:18px;border-radius:20px;background:rgba(6,17,43,.55);border:1px solid var(--line)}
.quiz .qk{font-size:12px;font-weight:700;letter-spacing:.12em;text-transform:uppercase;color:var(--blue-soft);margin-bottom:8px}
.quiz .q{font-size:17px;font-weight:700;line-height:1.35;margin:0 0 14px}
.opts{display:flex;flex-direction:column;gap:8px}
.opt{text-align:left;padding:13px 14px;border-radius:12px;background:var(--card);border:1px solid var(--line);font-size:15px;line-height:1.35;transition:all .25s}
.opt.right{background:rgba(52,211,153,.16);border-color:var(--ok)}
.opt.wrong{background:rgba(248,113,113,.14);border-color:var(--bad)}
.opt:disabled{cursor:default}
.fb{margin-top:12px;font-size:14.5px;line-height:1.45;color:var(--muted);display:none}
.fb.show{display:block;animation:fade .35s var(--ease)}
.fb b{color:#fff}
@keyframes fade{from{opacity:0;transform:translateY(6px)}to{opacity:1;transform:none}}

.next-wrap{margin-top:22px}

/* finish */
.finish{text-align:center;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100%}
.badge{width:96px;height:96px;border-radius:50%;background:var(--blue);display:grid;place-items:center;margin-bottom:22px;box-shadow:0 0 0 10px rgba(59,140,255,.15),0 0 0 22px rgba(59,140,255,.07)}
.badge svg{width:44px;height:44px}
.finish h2{font-size:30px}
.finish .score{color:var(--blue-soft);font-size:16px;margin:0 0 26px}
.finish .stack{display:flex;flex-direction:column;gap:10px;width:100%;max-width:320px}

/* bottom nav */
.nav{display:flex;align-items:center;gap:10px;padding:10px 16px calc(12px + env(safe-area-inset-bottom));border-top:1px solid var(--line);background:rgba(6,17,43,.6);backdrop-filter:blur(10px)}
.nav .dots{flex:1;display:flex;justify-content:center;gap:6px;flex-wrap:wrap}
.nav .dots i{width:7px;height:7px;border-radius:7px;background:rgba(255,255,255,.22);transition:all .3s var(--ease)}
.nav .dots i.on{width:20px;background:var(--blue)}
.nav .dots i.seen{background:rgba(143,184,255,.6)}
.navbtn{width:48px;height:48px;border-radius:14px;display:grid;place-items:center;background:var(--card);border:1px solid var(--line)}
.navbtn.primary{background:var(--blue);border-color:var(--blue)}
.navbtn:disabled{opacity:.3}
.navbtn svg{width:22px;height:22px}

/* menu drawer */
.scrim{position:fixed;inset:0;background:rgba(3,8,22,.6);opacity:0;pointer-events:none;transition:opacity .3s;z-index:20}
.drawer{position:fixed;left:0;right:0;bottom:0;max-width:560px;margin:0 auto;max-height:85dvh;overflow-y:auto;z-index:21;
  background:var(--navy-900);border-radius:22px 22px 0 0;border:1px solid var(--line);border-bottom:0;
  padding:10px 16px calc(20px + env(safe-area-inset-bottom));transform:translateY(105%);transition:transform .4s var(--ease)}
.menu-open .scrim{opacity:1;pointer-events:auto}
.menu-open .drawer{transform:none}
.grab{width:40px;height:5px;border-radius:5px;background:rgba(255,255,255,.2);margin:0 auto 14px}
.drawer h3{margin:0 0 12px;font-size:13px;letter-spacing:.12em;text-transform:uppercase;color:var(--blue-soft)}
.toc{display:flex;flex-direction:column;gap:6px}
.toc button{display:flex;align-items:center;gap:12px;padding:12px;border-radius:12px;text-align:left;font-size:15.5px;font-weight:600}
.toc button.cur{background:var(--card-hi)}
.toc .n{flex:0 0 30px;height:30px;border-radius:9px;background:var(--card);border:1px solid var(--line);display:grid;place-items:center;font-size:13px}
.toc .st{margin-left:auto;font-size:12px;color:var(--muted);font-weight:500}
.toc .st.ok{color:var(--ok)}
.reset{margin-top:14px;font-size:13px;color:var(--muted);text-decoration:underline;padding:8px 0}

@media (prefers-reduced-motion:reduce){*{transition:none!important;animation:none!important}}
</style>
</head>
<body>
<div class="app" id="app">
  <div class="top">
    <img src="data:image/png;base64,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" alt="Prime One">
    <div class="crumb" id="crumb">Store Manager Guide</div>
    <button class="iconbtn" id="menuBtn" aria-label="Open topic list">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M4 7h16M4 12h16M4 17h10"/></svg>
    </button>
  </div>
  <div class="progress"><i id="bar"></i></div>
  <div class="stage" id="stage"><div class="track" id="track"></div></div>
  <div class="nav">
    <button class="navbtn" id="prev" aria-label="Previous"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"><path d="M15 5l-7 7 7 7"/></svg></button>
    <div class="dots" id="dots"></div>
    <button class="navbtn primary" id="next" aria-label="Next"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"><path d="M9 5l7 7-7 7"/></svg></button>
  </div>
</div>
<div class="scrim" id="scrim"></div>
<div class="drawer" id="drawer" role="dialog" aria-label="Topics">
  <div class="grab"></div>
  <h3>Jump to a topic</h3>
  <div class="toc" id="toc"></div>
  <button class="reset" id="resetBtn">Start over (clears checkmarks and answers on this phone)</button>
</div>

<script>
const PHOTO_BASE="https://primeone-consulting.com/wp-content/uploads/2026/10/"; // photos live in the primeone-consulting.com media library
const COVER_IMG="p1-store-manager";
// tall (portrait) photos are shown whole, with the title underneath instead of on top
const TALL={"p1-day-inspection":"900/1124","p1-day-handoff":"900/1124","p1-day-safety":"900/1124","p1-day-priorities":"1200/675"};
const FOCUS={"p1-day-inspection":"0%","p1-day-handoff":"8%","p1-day-safety":"6%","insights-06-detail-manager-day":"22%",
  "p1-day-team":"8%","p1-day-priorities":"22%","insights-04-gm-changes":"28%","insights-08-pdi-lot-refresh":"28%","p1-operations-manager":"30%"};
/* ===== CONTENT — edit here to update the guide ===== */
const GUIDE = [
  { title:"Start the Day Right", img:"insights-06-detail-manager-day",
    lede:"How the morning starts sets the pace for the whole store.",
    items:[
      "Show up on time and ready to lead",
      "Set up the work area so it is clean, organized, and supplied",
      "Confirm invoices from the previous night were sent",
      "Review notes, unfinished work, or early vehicles left from the previous day",
      "Check today’s work in KeyTrack or on the key board and assign priorities"
    ],
    quiz:{ q:"Before you assign today’s priorities, where do you check the work?",
      opts:["The dealership’s group text","KeyTrack or the key board","Yesterday’s invoices","Wait for the sales manager to call"],
      a:1, why:"Today’s work lives in <b>KeyTrack or on the key board</b>. Check it first, then assign priorities." } },

  { title:"Team Readiness & Timekeeping", img:"p1-day-team",
    lede:"Your team reflects Prime One to the dealership every single day.",
    items:[
      "Make sure employees arrive on time, in uniform, and ready for work",
      "Make sure employees are clocking in and clocking out correctly",
      "Keep the work environment professional — no blasting music, smoking, intoxication, or toxic attitude",
      "Check whether any detailer needs coaching, correction, or support",
      "Verify that the team is pre-checking customer vehicles before work begins"
    ],
    quiz:{ q:"What must the team do to every customer vehicle before work begins?",
      opts:["Take it for a test drive","Pre-check it","Move it to the front row","Nothing — start right away"],
      a:1, why:"Verify the team is <b>pre-checking customer vehicles</b> before any work starts." } },

  { title:"Quality & Training", img:"p1-day-inspection",
    lede:"Great stores catch problems before the dealership does.",
    items:[
      "Check the quality of vehicles coming out of the department",
      "Touch up showroom vehicles as needed",
      "Identify whether issues are caused by training gaps, weak quality control, or broken communication",
      "Coach and train detailers early when standards slip",
      "Help build people who can take on greater responsibility"
    ],
    quiz:{ q:"Quality is slipping. Which three causes should you look at?",
      opts:["Weather, traffic, and supplies","Training gaps, weak quality control, or broken communication","Pay, hours, and schedules","The dealership, the customer, and the car"],
      a:1, why:"Find out if it is a <b>training gap, weak quality control, or broken communication</b> — then coach early." } },

  { title:"Workflow & Lot Management", img:"p1-day-priorities",
    lede:"Keep cars moving and the lot looking sharp.",
    items:[
      "Watch workflow throughout the day and keep turnaround close to 24 hours",
      "Check lot appearance, including clean vehicles, plates, and stickers",
      "Look for vehicles waiting on detail or vehicles we still do not have access to",
      "Spot bottlenecks on the dealership side and help keep cars moving",
      "Track any in-transit inventory and plan ahead"
    ],
    quiz:{ q:"What turnaround time should you keep the store close to?",
      opts:["About 4 hours","About 24 hours","About 3 days","About a week"],
      a:1, why:"Watch workflow all day and keep turnaround <b>close to 24 hours</b>." } },

  { title:"Dealership Communication", img:"insights-04-gm-changes",
    lede:"Be the person the dealership trusts to get it handled.",
    items:[
      "Greet the GM, Sales Managers, Service Manager, and staff",
      "Build trust by becoming the dealership’s local Prime One point of contact",
      "Ask where help is needed and align priorities when volume or needs change",
      "Look for ways to remove bottlenecks and support the dealership proactively",
      "Fill out the Daily Pulse accurately and on time"
    ],
    quiz:{ q:"Which daily report must be filled out accurately and on time?",
      opts:["The Days-Off form","The Daily Pulse","The invoice log","The incident report"],
      a:1, why:"The <b>Daily Pulse</b> — accurate and on time, every day." } },

  { title:"If a Vehicle Comes Back", img:"p1-day-handoff",
    lede:"A comeback is a signal. Treat it like one.",
    items:[
      "Correct the quality issue promptly",
      "Identify what part of the system allowed it to happen"
    ],
    ask:["Was it a training problem?","Did quality control need tightening?","Was communication broken or unclear?"],
    callout:"Fix the cause, not just the car.",
    quiz:{ q:"You fixed the car that came back. What’s next?",
      opts:["Nothing — it’s fixed","Find what part of the system let it happen and fix that","Write up the detailer immediately","Tell the dealership it won’t happen again"],
      a:1, why:"Fixing the car is step one. <b>Fix the cause, not just the car.</b>" } },

  { title:"If Damage or Injury Happens", img:"p1-day-safety",
    lede:"Follow these steps in order. Speed and facts matter.",
    steps:true,
    items:[
      "Identify what happened immediately",
      "Photograph and document the facts",
      "Notify your Prime One supervisor right away",
      "If a vehicle or property was damaged, notify the appropriate Sales or Service manager",
      "If someone was hurt, make sure the incident is reported and handled promptly"
    ],
    quiz:{ q:"Right after identifying what happened, what’s your next step?",
      opts:["Notify the GM","Photograph and document the facts","Send everyone home","Move the vehicle"],
      a:1, why:"Step 2 is to <b>photograph and document the facts</b>, then notify your Prime One supervisor." } },

  { title:"If Staffing or Volume Changes", img:"insights-08-pdi-lot-refresh",
    lede:"Short-handed or slammed — the dealership shouldn’t feel it.",
    items:[
      "If a detailer calls off, complete the Days-Off form",
      "Assess the situation and adjust priorities",
      "Notify your Prime One supervisor and request help if needed",
      "Do your best to minimize or eliminate the impact on the dealership",
      "If volume increases or the store falls behind, set an execution plan and align priorities with the dealership"
    ],
    quiz:{ q:"A detailer calls off. What do you complete?",
      opts:["The Daily Pulse","The Days-Off form","An incident report","Nothing"],
      a:1, why:"Complete the <b>Days-Off form</b>, then adjust priorities and get help if needed." } },

  { title:"Conduct, Coaching & Escalation", img:"p1-operations-manager",
    lede:"Small problems handled early don’t become big ones.",
    items:[
      "If you see a pattern — tardiness, attitude, quality, speed, or other conduct issues — address it early",
      "Have the conversation before the problem grows",
      "If there is no immediate improvement, issue a verbal warning and notify your Prime One supervisor",
      "If the pattern continues, hand the matter off for further action"
    ],
    callout:"A manager does not ignore problems — he or she owns them.",
    quiz:{ q:"You had the conversation and nothing improved. What now?",
      opts:["Give it another month","Issue a verbal warning and notify your Prime One supervisor","Terminate on the spot","Move them to another store"],
      a:1, why:"No immediate improvement means a <b>verbal warning and notifying your Prime One supervisor</b>." } }
];
/* ===== END CONTENT ===== */

const KEY="p1-mgr-guide-v1";
const store={get(){try{return JSON.parse(localStorage.getItem(KEY))||{}}catch(e){return {}}},
             set(v){try{localStorage.setItem(KEY,JSON.stringify(v))}catch(e){}}};
let S=Object.assign({pos:0,checks:{},answers:{}},store.get());
const save=()=>store.set(S);

const check='<svg viewBox="0 0 24 24" fill="none" stroke="#fff" stroke-width="3.2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12.5l4.5 4.5L19 7.5"/></svg>';
const esc=s=>s.replace(/&/g,"&amp;").replace(/</g,"&lt;");
const track=document.getElementById("track");
const total=GUIDE.length+2; // cover + chapters + finish

// shuffle options per question once, deterministic so answers stay stable
function order(n,seed){const a=[...Array(n).keys()];let s=seed*9301+49297;for(let i=n-1;i>0;i--){s=(s*9301+49297)%233280;const j=Math.floor(s/233280*(i+1));[a[i],a[j]]=[a[j],a[i]]}return a}

function build(){
  let h=`<section class="screen"><div class="cover-bg" data-bg="${PHOTO_BASE+COVER_IMG}.jpg"></div><div class="in cover">
    <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAFzCAYAAAAQb1/gAAAio0lEQVR42u3dd7QsZZnv8e+z9z4c4BAkiJhBTHMHdaEo5hmdGXXQcXAMgOSgIsogetdgwARjDpgDYAAFLgqiM+Zwce6Vi44sFBMmVEAli4QDJ+1+7h9V7Wn6dPfuUN27w/ez1l5nnx16dz1V9f7qrXrrrUATKzPvDewHPBxYBcwDUX40inYv0cefjQq+nuVHNP3MXIe/W+txGbLH99lpeeeqWF0t3lP08X76ea/Rpi6LbeoawEKbdbBY0XtdaHjNGvAH4HvARcBlEbHOPXz8hSWYyODYFjgWOBjYzYpoitxYBsmbI+JCy2GAqNrw2AE4A9jbamiKrQXeBZwYEWsthwGiwcNjC+B04LlWQzPiHOBFEXGzpRg/c5ZgopxoeGjG7Au8NzO3tBT2QNR/7+OAsvcxbzU0g04HjoqINZbCAFFv4fEQ4JvATlZDM+yTwIsNkfHhKazxD4+7AZ8wPCQOBT7o6SwDRN2Fx0rgzcAjrIYEwOHARzNzK0thgKizV5Y7jKSNDgTOLHvnWkZeAxnf3sehwEeBzayG1NI3gYMj4mpLYYBoY3g8FfgssLXVkDr6BrB/RNxoKQwQwyPz/sDXgPtZDakrXwKOiIhrLcVoeQ1kvMJjc+CthofUk6dTXFjf1lIYILPsBODZlkHq2T8DZ2fm9pZidDyFNT69jyMoLpp7p7nUv68Bh3g6ywCZpfD4e+BcwC64VE2IHBERf7AUBsi0h8cuwBeBv7YaUmW+DhwWEX+0FMPjNZDlDY/NgXcbHlLlngKclZn3sRQGyLQ6AXiWZZCG4m+AM7xj3QCZxt7HAcDLrYQ09BCxJzIkXgNZnvDYC/gC4JGRNBoXUjzZ8KeWwgCZ5PDYDfhP4K+shjRSlwIHRsRPLEU1PIU12vDYHHiP4SEti4cBn8jMXS2FATKJ3gA8wzJIy2ZP4LxyzjkZIBPT+zgYONZKSMtuD4rniTzQUgzGayCjCY/HA58D7mo1pLFxCXBQRPzMUhgg4xoeu1I8s2A3qyGNne9R3LF+maXonaewhhseK4GTDQ9pbO1FcTrLayIGyFiFRwCvo5hmWtL42gM4JzMdHdkjT2ENL0D2B04HVlgNaSL8lOLxuD+2FAbIcobHo4HP453m0qS5hOJmQ6+JGCDLEh7bAt8CHmE1pIkNkX0j4teWojOvgVQbHptTPFXQ8JAm18MpronsbikMkFGFxwJwIrCv1ZCmIkQ+l5l7WAoDZBRehNOzS9PkARRTwXtGoQ2vgVTT+3gKcDawvdWQps5lwAER8QNLYYBUHR67AF8FHmQ1pKl1OfCciPihpdjIU1iDhceWFBfNDQ9puu1GcWH9kZbCAKkiPAJ4J/AUqyHNhAcC/6u8z0sGyECOAI60DNJMuR9wRmY+ylJ4DaTf3sc/AOcA21kNaSb9FtgvIv7bAFEv4fEA4Cs4w6406y4vQ+TiWS2Ap7B6C48tcHp2SYXdgPMz8zEGiLrxBuDplkFS6V4U10SeNIsL7yms7nsf+wJnAJtZDUlNrqa42fACA0TN4fFk4Fy8aC6pvWuAvWfpjnUDZOnw2A34MsUYcEnq5ELgqRGxehYW1msgncNjG+BDhoekLj0O+KdZWVgDpH14BPAWvNNcUm+OyMx5A2TGNwLghZZBUo8eDOxigMxu7+PJwPuABashqUf3BPY2QGYzPFYBrwO2sBqS+hDATgbIbHoIsKdlkDRgiBggM+hHFDcMrrMUkgyQ9jzH37zWI27PzGOB04C7N4Rslh91tQ4vkwNsUL2Geq2Lvz2MnSIa/l/r8HeXa0eaa6pJtlmPS73Pdsvcbl21e/0EFrt4r0ut/+zwN1q95+xh3UQX7yNa/F6tzbLNAVsDdwWeBTx5hpqSnIWFNEBah8h64BIrIVXUmmZ+HHgpxfXFVTOwyN5IKElV9ewj4u0UT/GcdjXgKgNEkqr1YeCXU76Mf6SY0sQAkaQKeyLXApdN+WLeClxngEhS9a6f8uVbnJUVaYBIsoGt1gZmZBSWASLJdqda6YqUpOGY9plql7pPxwCRpD5N+/1n9kAkyXZHrkhJ42TeEhggkmSAGCCSNDLOwWeASJI9EANEkkYgMwNHYRkgktSHAFZYBgNEkvoJEE9hGSCSZLvjipQk2x25IiWNsVbPVJcBIkldBcgsjMJyMkVJqtgKHIVlgEiSDBBJUnW8kVCSJANEkmSASJpotfJDBogk9WQDsN4yGCCSJANEkkbGU1gGiCT1bGbu0jZAJEkyQCRJBoikSeUDpQwQSeqb10AMEEkyQGY5IA0QSTawMkAkTUR4pMtogEiSPZAZ7mEZIJJGzTvRDRBJ6uvo3AAxQCSprwBZtAwGiCT1JCIMEANEkvpmgBggktQXr4EYIJLUl80sgQEiST3JzHsDD5ryxQwDRJKq9xBgV8tggEhSrw623ZkeC5ZA0rBl5krg5cBzrIYBosncibcAVgErKUbCzNH+fG19vP4iG+f2aTXHT7T4vSXfStPvNr/GfPneOr2/pf5e9Pjz7b7e64ihAFY0/f1g0wn26vWt0XpY61y5f7Zajg19vN926y57/PnooXYLFKer9gKeCTzJvdAA0eQFxwOAY4BHATuWAZJdNLT1aSf6CZDsIUDmWgRKdGiwhlKmHr/eyXyXDW2tqb7NAdJu+WtLrLMqatFLgLRatvrPbgds415ogExzA7slsFNE/G4Kl+1xwKeBXVzTkqrkxazCMcB3M/MfpzAY32Z4SDJAhudBwN2AMzPzaVO0XHsCj3X1SjJAhmd9+e92ZYjsMyXLdR9m6KYmSQbIctseOD0znz0Fy7Kdq1OSATJa2wAfmYKeyEpXpSQDZLhaDVncETgtM587ZcslSQbICBraHYBPZOaBlkiSDJBej9RXAadk5pGWSZIMkF4CBGAL4P2ZediELZcjsCQZIGNgc+BDmXnUFAWjJBkgIzpS37zsibwyMyfh6H6Dq1aSATJc8z387ALwZuDEzJwf8+VadNVKMkDGowfS+POvBk7KzHF+vnPNVSstS3syE9cfDZDBavdK4HgDRJI9EPVzpPHaMb4mYoBIMkDG2ArgTRTXRFaM2XtzFJYkA2TMG9o54ATgHZm5tQEizXx7MhP7ngFSbUN7LPDW8tnjrl9JBoh6cjRw6pj1RCTJABmSqi82H0Axf9YqSyvJAJluwzhfuR/FdPD2RCQZIAZIXyHyPnsikgwQA6QfhwIfzsxtLLMkA8QA6dVBFBfWtxrxcjmduzR6TmWiyj0POMOeiCQDxB5IP54FfCoz72LJJRkg6tUzgdMzc3tLIckAUT8h8snM3M5SSDJA1Kt/As7OzB0shSQDxDr06qnAZzLzHkN6fSdTlEZvZkY/GiDL78nAZzPzXm7IkgwQ9eqxZYg8wFJIMkDUq0cD52bmgy2FJANEvXpo2RPZtaLX8xSWJANkhuwOnJmZ96/gtXwmujR6MzN4xQAZzyP1xwCfzswHGSCS7aoLaoD0ai+K+0Tu55GQJAPELmev9qC4sL6bASLJADFA+gmR8zLzf7iaJBkgBkivHkZxOutRPf6eo7AkGSDioWWIPMYAkWSA2APp1f2AszLzEV3+vKOwJBkg+otdKC6sP94eiCQDRP2EyDmZ+VRLIckAUa/uQfGM9WdYCkkGiHq1E3BaZv6dpZBkgKhXd6M4nfVESyGNhZkZvGKATIcdyhDZ21JIy27drISIAVKYhtFKO1PM4vu8hq9t5aqVRm49sDgLC7rgup6aAAG4C8U1kQXgQmB/V600cpdHhAGiibQ18Eng98CulkMauTNnZUENkOnqgdStMDykkdsAnAp81wAxQKbZTcCVwJ8ppnGJ8mOe4rrYfPlzSXExsP6RTTWr163+e93Utv7/ufL1suG1axTnjrPLdRVUOw1Nq+2gn9fPNl/r9cLqXFOdo0XtabNOBtm+ax3e61zD8jX+u1jRPldrU7/GWrT6vNvXiYbtu3n9ZIdgyDb1X1P+rd8BXwPOjYiZeYyCATJbAfIb4B3lhn7NEjsGLRqJpRrzQRvp7LHBHtcA6SVYenk/McLtOIf8872+TqttLUa0nju9p0WAiNgwiw2nATI7zgGOiYjrLYWkKjiMdzZ6IL8E/qfhIckAUa8ujIjfWwZJBog9kF6sA853FUsyQNSrNcDPLYMkA2Q4pnnY3SI+mVCSAaI+wzEtgyQDRJJkgEiSDBBJkgEiSZIB0i0vMkuSAWKANGk3Q6skGSCSJAPEHogkGSAGiCQZIJIkGSAteZFZkgwQ69AiHA1ISTackiQDRJJkgEiSDBBJkgyQrnkfiCQZIGriKCxJBogkyQCRJBkgkiQDRJIkA0SSZIAM3zSPUkocpizJAJEkGSCSJANEkmSASJJkgEiSDBANto6dC0uSASJJMkAkSQaIJMkAkSTJAJEkGSDD5VxRkmSASJIMEEmSASJJMkAkSTJAJEkGyCAWLYEkGSCSJANEkmSASJIMEEmSDBBJkgGilpznS5IBMkQ+8lWSDBBJkgEiSTJAtGwSr4NIMkAkSQbIeKlN8bIFDhKQZICozwCRJANkSLxGIEkGiCTJALEHIkkGiCTJAJlG03yh2d6VJAPEOkiSDac9EEkyQCRJBogkSQaIJMkA0SC8viPJALEOfS+b61mSDackyQDRaCwy3dPVSzJANCTrgPWWQZIBol6tLj8kyQBRT34L3GwZJBkgwzE/xct2fkSscxVLMkDUi9uAb1oGSQaIenVKRFxmGSQZIOrFFcB7LIMkA0S9WA+8OiKushSSDJDhmran9n0qIs5ytUoyQAyQXnwMONpVKskAUS8+BxwXEWsthSQDZDSmYa6o/w0cGRG3ujolGSCjM+mnsH4IHBYRN7kqJRkgBki3rgYOj4grXY2SDBB160bg4Ij4gaWQZICoW3cAx0SEU5VIMkCW0aQ9N3wD8G8RcbarTpIBYh26lcAJEfEBV5uk5bRgCSaqB1ID3l5+SJJH3gZI194JvDYi0lUmyQAxQLr1aeD1EbHB1SXJABkf435EfwHw8ohY46qSZICoW78AjoiI6y2FJANE3boc2DcifmspJBkg6tavgP0i4lJLIckAUbeuAQ6JiIsthSQDRN26CTgwIi6yFJIMEHXrduCFEfEtSyHJAJkM43AfyCJwfESc6+qQZICoWwm8A/iQpZBkgKgX76OYoqRmKSQZIOrWKRRTsztFiSQDRF07D3hZRKyzFJIMEHXrq8DREXGHpZBkgKhbFwNHRcR1lkKSAaJu/Qw4LCKusBSSDBB16xqKu8x/YikkGSDq1tXAv0TEDyyFJANE3bqRYnJE57eSZICoa7cCL46Ib1gKSQaIurWe4ibBz1oKSQaIevGqiPiIZZA0jRYswVAkcCJwsqWQZICoWzXgXcAbIyIth6Rp5Sms6r0XeKXhIckAmQ1VNfbnAK9xWnZJBoh68SWcHFGSAaIeXUxxr8efLIUkA0Td+jXFXeZXWQpJBoh6CY/nRcTPLIUkA0Tdup5iWnYnR5RkgMywXkdh3UBx2uo7lk6SAWKAdOsm4PCI+Iplk2SAqFtrgeMj4j8thSQDRN2qUdwkeKqlkCQDpC66+JmTcHJESTJAegyQtwJvcooSSdrI2XiXDpCzcH4rSbIH0ka7cDgPOMLwkCQDpJ35Fl/7FnBURKyxPJJkgLSz2PT/rwLPj4gbLI0kGSCdNJ6iugA4NCKusyySZIAsZQ1wB3AGxeSI11oSSdKSMnPnzHxEZhqokiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJnURmvgg4BFgJ1IAEVjT8TALrgUVgrs3rZLvXb/qZWsO/ASyU31sNXAN8A7ggIq501UjDlZkB7AEcCDwW2LzcL+v7c63c9+vmGvbraNi/s+Gj1rTvR4s2of43FsufX2z4/xXAmcCPIuIa19L4b0QfzPFyRWYel5krXTvS0Pb7e2XmGZl5a46f9Zn588w8xDU13haAdWP2nu4DvLv8/GRXkVR5eGwLfAR4+hi3Sw8CTsnMWyLifNfaeJob4/f2msz8K1eRVLmXjXF4NNqsbAe2c5WNb4BEtwcuFOcr6+csF4ENDZ/XWnwstvjY0PB7newA7OsqkirtfWwFPGuC3vIewD6uufHtKrbrhVwHvA64uvx/q5CgDKB2QZQN/yZ3vtg+B9wDeCmwZ5v38HBXkVSpXcr9rtltwEnA5Q37dvPgmKD9gBna/A4t2pjmtqI+QOf5wHNa/O6ewCdcdZMVID8DTo2I2pCPiL4BfBNodbpqq8zcPCLWzOCR4l+COSI2uKmqIjsCW7T4+tXARyLilmXc5u/aIkBoE3gakwBpdwprDSO4yB4Rf8zMzwGv6bCxr+lxQ9weeBWwTdkIryyXs376rNbweb1xni9/Zr7h84WGnteG8n3UhzTPN3ztj8DPgV9GxJ8G2IHuD7yyfM9blu97ITM/GhFf7PM1F4BXAPcGbimPEFcDp0fEH5ahkXg0cBBwe1m/LYCryoOVW/p8zScBzyiPordsWIdzbBwe2jjEdI5Nh6RuaHP0XH+t5qPr+vaRwCkR8cMJ2ed3Ala1+PrahuVcLu3281WZOTfowWxmPgI4oNwOdgRuBT42inVXnjp8EbBzuZzzFEOWPx4R6/t8zfsBx5Tb4WYNbRkN23u9LVtsOnPUuI80326RwB1svO1ijo23dqwv65bAOZ16IHew9HWKqlzaIeCyj9fbBTiWO9/PMgoXZ+ZhEfGTPn//ocARLb5+HfDFPl9ze+BfWxzF/U1m/vMoe3eZuTtwLnDPpm+tBy4ALunzpZ8HHLWMDd+fgEkJkJVtDhrvaGqAlkO7/XVV2U4NejbkMOAlTV97RmbuHxHfHUFwn1ge4NT9BjgH+HOfr/kYigERy+WaThfRa2Owsdf6DBBYnuHJewJnZebd+vz9doG9foD3FG1+/ynA20cYHtsA72sRHvWj30EOVnKZt9M7Juisw9wMv7e5Ngeb52fm00bQlt1R4X4N3Q+AGpa1c0vslKPaMTd0aFCTyfIQ4OVVt78DbmTt1vNRmfncEYRHAMcDT+qwcw1ywLLcp14mKUDmx2B/77VBnB/yOt4ZODszDy+31aHsBkM4KF/ug4HaAuPRQI/qVNmNwGcbuuuLLVZuY68suPMIsmTjecPdgae1WYl7Z+YbI+L2ijaIGMJOWT9l8KHM/F1EfH+IdX8mxXWYTu9xkGWcb7PD/l/gFxTnh9eUvdLG3k7zlBxzTeui+fvNP7t5+VrfmqAAySFsY8MOkLkRvL+7AB8FdsnMk/q9LtHj8g1juwf4HfBtitNlwcZrt/XrgY0H5sGmI2nrt1vUD+warwtvUb5WDbh0oUMqxgg3qqo36nav98WIeHFFR9UrKeYQex/FeeVGW5cft4/BTjm3xJHKjsA7M3OfiLhpCL2P+wDvbFGjYfs9cEBE/B5V1Ztdzl5TFUfbS7UnC8BrgZ0y82UVXx9sdSZg0GCca7N+XxsRn87M+uvXIiKH1bjkmGzUWWGAtFsxv6hsa4hYC5wK/L82G+KKCdrpnwi8awjhsTnFtDT372PnGtRtwA3mxaanHcb4vc31eRBU9bK/CPh0Oay4ygCJEdQryx4IEVGLiMVhhUf9DdQ6nN4Y5bnlqLDoMYqGuFwxV1a4wecQdvpW72V1+dHogMx8fsXr9Fjg2Q3/vwH4DptePBw0QDaMKJSmwYaKe/tV9zTabcNVtEVrW3ztV+U22ezZwHmZuWuFB4G1imvers3cYpSJPw49kHanN9ZVfMQ0jGVdHNOdsVPv7ivA0UDjKavNgPdk5kMq6n08keJenEavobjPpeoRcrURHfFNg0m8BjLM7eRSiqldzm7xvScA51S1T0xRHZfsMtaPBkYVLg/soXEeZCdZHOEKjDFZ8a1GOF0XEWew6WmruwInDzp5XXnd4wPAtg1f/g/gdIqLlVtU3FtYRIM0orMcnltHxA0U9xGd1eL7jwS+kJmPG8KB3LCCYiwC5LYhjURobmx2obgY3W3jN247T20Cdpps0+N7N5veoPh3wL8PsD43o7i/pPGo7Q/AceV1oxVD6C3McqNYZQ8kZnDZMzOjnAXhhRQjsZrtWobIM0a0Lsaup9HOQofv/XVm/i3FkwJXlac41rU4YsymI8DGJ5PNd9hAtwIeBhxMMfd/K9fR3xj7dmk/jCPVWoUrN/oI+m7eX3Mt1gJExB2Z+WqKp9Ft3/D9IzPz+xHxyT7+3hFA470lq4FXRMRvyv9vGMKRWK1NzQyW6hutST710mp7WFe/yBwRqzPzpWU7d3RT+7UDcGZmHlP23seh9nNtargwDgGyO/D5spj1C+qLbVZ0tmnA55q+H01/e6sl3t9vhz2ZYwXWt9lQxuV9t+rF/eUUUkT8uNxpTm/oHWwG/HtmXhIRP+qh9/FIiukaGjfs0yLinMYddkSN2GYUc6FN0k1+sx4sudx/MyI2ZOZxFAM+XtvURm5Dcd/U3YG3VzC6qTbgMrc7sNx2lAHSaXTDtsu4Ma2muOlv3DfEbVp8rZvnnfRivuKNtPkA4Bzgcdx5nqB7UlwP2Scibu0iPHYAPkRxX0ndBcAbujgKHPT8cKv63IdiFM2vy20py/Baz51vEK3vBysobgzM8v/fpZjobtp6MfPMrvluGuGIWAROzMyrKZ6K2jj55CrgTcA2mfn6HmbKbnWdb1h3/78+M59QtkHrWvTGs2l/rA+m2gy4HnhHt/fALDCe5z3XUzyL5DsVd4UrDcTM/Htg7xbfqt/JWVXwDXUdRUQtM99IMZfXXg3fenJ5FPZvS9RhvtypGp/rcjPwqoj4c5fb3KDTtbT62uPKj37sCXyK1kM/J9ly3u09jsseHfaLUzPzBopnkWzbFESvBnbOzGMj4rYxW5cPpP3ApKXcRHF/2zXdBsg4uRn4JfBW4PMDdBHbXRA8sLyDfJHWU3jPs+lNgPUp39c19SruS3Guf/s2vafVI9hQKjtVEBHXZ+YxFEN8d2j41r9m5tciotN0Hfux6SzCJ0fE99qE6yh6IP2qT9W/msEnuxtHcyPaxqo06Kmevtu7iDg/M9cCpwF3b/r24cC9MvPIiLiqjzZpXAaP1Brey9peXrfTXFhrKK6B3Fg2qPVng9S6WOjs8qiyvkJvAa4FLgR+HBGDNr7tGqQHlEcOw/YfFR+VxCh+NyK+n5mvB97f8HsrKe4PeXpEXNmi97E78JamnfNi4D1t/swKWl9DG5fJFOuvtWEKT191akQ7PdphHAKkilPCK/rp+UbElzNz/zJEmmdVeArFqdIjl7he2OoU1qChXdXpr7mm97Rh0I0JimczHFoOvVT3vksxPHacuu3Rw4b7YYqnQzZeD9kdeG9mHtQYjJm5iuJekns3/OwtFKOubu7QGNRofT64apcAP2bjncxrGnaOWsPn2dDbqPdA/ntKt89x7oHkMi17NwdX/5WZT6cY5vu3Td9+JHBuGSL/p4IzJYPW6zcU913V2Dgf31Yt/laNjado11Bc37mml7MnnQJkPbN9wa1Xt5Wnf46PiOsnbMdq3FFqZS/kscAeDd/ah+LBVG9u+NoJ5RFY4/t8yxI70Xpaj9qr+mj/WmDfiPi1m+bYBUWv23lVF5tjwH3jl5m5H/BB7jxFT/3sxrmZ+YKI+MIQe1Hd1OttEXHKcnZnofppRJb7qBuKEQbfbmjE5th4PWSz8mfuQfsLr2spTrOtLn/n9rJOPwO+AfygHMExTkERvR6JRcSNmfmSMhAbLx6ekJk/iIivZOY/Usx11eicLnpfrS6iL1L9A6VuppiRV92ZH4Nw6RQgY9EWRcS1mXlI2QYc3PTtu1I8V+SYiPhYFyE46BxfGzocPI3EQocddxIf5tSY9q3e+5kRcVzHLThzy/Io+9g2ofq2iPh6efdqjmgHGkaYLrWjXJSZJ1HcVV4PnC0orofsXNancUqSyyhGXa3rYpuLqk4tdKjbPOM3SERL77fL2gPvct9YnZlHl++reRaN+j6yVUS8d4n9cNBTWO32m5E9ynupu3VzyjbQP3SxcdxO8fCjt7VY/q0prgU8YZhTJA9hPfS7kZ5MMZS10QOBj1PMIlB3K/DiiPhdlwctPfeK+mx4ZK2W2o/62jfKgT5HUQw4abYV8PbMfGPDEw6rmpJ+rNbx3JRuaO3OmW7d5caxSDGT7PFsOpTzwRTnOp8z7Tt9OQrpBIoZSzt5fUT8V5cvu2IIp0oW22zbzsbbXa3G5uC+x/25kr/Z72Nsy5vtjqO4Z635/W1Wfv0DmbktxenuxWlrL+aW2NCmrQcy38PGkRHxjjJEmu/K3InigTMvLp/6NbXKJ/q9jPYjM75AcVFxkEZiGMMZx/UmWQOk94avqnYoq972ygc2nQS8gDs/HqHuaIqRWw9vcTA68e3rtPZABg6Qhg3k5LI30hwiK8vu6xvLO7HH+aguBtlwI+LbFM/xaN4mLgNe3sV1j6V22CrmFOpmudW5kV7uBi0n9fXLi+YHAq1uKNwXOJPiIvsoemxjEyCTGiKV7gwR8R6K852rWwTSq4GPZ+YWy7DTj3JH+iDQOAvprcDRDbPsdqvVMN5Bhzi2CrANTF8Pugrt7rBfGIN6tdsGbqW/qYGare2xDey1nfgysD/w2xbfvgubDurIIfUIR3YRfan7QCY5QCptiCPi9MysN6SrmjbAg4FVmfmSiBhkCF1tCKcdKgnTiMjMfAXFdaRHUYxG+3YfL7WmzfvJihueUT+SeVJcRvGYhHs2fX1X4KTM/EnZYDcO42+c4mdFmyPgbNPrax4R2XhHdjRsE2uB57V5z1cNODy+03ZS6VF8RFyYmf9C8YTDB4/yQHc5eiYLfRwNTHIPZHHAjeP0zLyD4m7t5jmwng3cLTMPj4hfDeH0QpWBmn0u/58y80Bgu4i4us/3cjubPitm0OVrdUS9M/DuzPxx+bfWl41iNPzt+r0Piw3vo7nBa34UQWNDuZ5ixM1XI+KnE7JvXFEeId+zRVtwzJi+50srep0NbRrbqPiMxQ8zcx+KRyTstQw9tmPK2bEbn+G0omFZoyns6z2h+pmA5slg57nzPSu3lb/7rU4XGmsjHqq6nF3kXjaOz2TmzcAny0aq0eOBz2bmIRFx6RjXIQZY/jXA1QP87VaTtQ3jesU8cOiI6rkjmz7/fTxXfMT6zPxSua1Ogp8C543L/t9DnX9RjtQ8FXjakHoK7Zbn8SNav6+YY/mfHz6soGh1NH9HRRvH14CDaH1fycMoHn/5pAp7IIOcSmx1U+Vynpps9ayUQUf8bVjm7W3FhO0fH6ywUR6mmygGaVQ1o0CtTVsxlAPl8n0fAHymh31zLAOx3fvvdHPLJJ8/jjbvPyrcOL5JMZ37FS2+fV+KGToPysyFipanX9liHS/nul1ssTyDXq9Y7qHUE3WtsHxA2AvKILllDN/ieuBHFHOZfX3IZyCG/aydP1FcI31/i+1k0u9VWrNQHkVfWe7ENTY+cvTnE7xgtwC/KE8tzJVHqAvlcla5cVxUdlM/RvEEvDXl31soPz+x/Jvd3mT3R4rZY7csN6x15Wt9f4C3eVv5mvVrAPPA5cu4bq4vG4dVFOdog2Lo4w0DvOblZZ0XKYZXL7BxFGE2HWU2P5Z5jjvfJZwNH42jw+abdvj69zaneIbNZB1hRdwEvDQzTwMeQzHD7H3L5Wmc2r2xNs0XzRs/rzX8zFzTgVzzefe5Fg367eW2cRHFfHUXtXgY2aAupjgltlBuJyuBnw/7VH1ErC0fk3sdcFjDwdJvaD2CkB7ai2vL9q3WsC6iKSA7Xayvtdjm2x2g1RrW23rg9/8fRIDoedcXGWgAAAAASUVORK5CYII=" alt="Prime One">
    <div class="rule"></div>
    <h1>A Day in the Life of a Store Manager</h1>
    <p>Prime One Store Manager Guide</p>
    <button class="btn" data-go="1" id="startBtn">Start the guide</button>
    <div class="meta">${GUIDE.length} short topics · about 10 minutes · swipe or tap the arrows</div>
  </div></section>`;
  GUIDE.forEach((c,i)=>{
    const ci=i+1;
    const items=c.items.map((t,k)=>`<li><button class="item" data-c="${ci}" data-k="${k}">
        ${c.steps?`<span class="stepn">${k+1}</span>`:`<span class="mark">${check}</span>`}<span>${esc(t)}</span></button></li>`).join("");
    const ask=c.ask?`<div class="ask"><h3>Ask yourself</h3><ul>${c.ask.map(t=>`<li>${esc(t)}</li>`).join("")}</ul></div>`:"";
    const call=c.callout?`<div class="callout">${esc(c.callout)}</div>`:"";
    const ord=order(c.quiz.opts.length,ci);
    const opts=ord.map(o=>`<button class="opt" data-c="${ci}" data-o="${o}">${esc(c.quiz.opts[o])}</button>`).join("");
    const last=ci===GUIDE.length;
    h+=`<section class="screen"><div class="in">
      <div class="hero${TALL[c.img]?" tall":""}"><div class="ph" data-bg="${PHOTO_BASE+c.img}.jpg" style="background-position:center ${FOCUS[c.img]||"30%"};${TALL[c.img]?"aspect-ratio:"+TALL[c.img]:""}"></div><div class="hero-in">
        <div class="kicker"><span class="num">${ci}</span>of ${GUIDE.length}</div>
        <h2>${esc(c.title)}</h2></div></div>
      <p class="lede">${esc(c.lede)}</p>
      <ul class="items">${items}</ul>
      <p class="hint">Tap each line as you take it in.</p>
      ${ask}${call}
      <div class="quiz"><div class="qk">Quick check</div><p class="q">${esc(c.quiz.q)}</p>
        <div class="opts">${opts}</div><div class="fb" id="fb${ci}"></div></div>
      <div class="next-wrap"><button class="btn wide" data-go="${ci+1}">${last?"Finish":"Next: "+esc(GUIDE[ci].title)}</button></div>
    </div></section>`;
  });
  h+=`<section class="screen"><div class="in finish">
    <div class="badge">${check.replace('stroke-width="3.2"','stroke-width="2.6"')}</div>
    <h2>Guide complete</h2>
    <p class="score" id="score"></p>
    <div class="stack">
      <button class="btn" data-go="1">Review from the beginning</button>
      <button class="btn ghost" id="menuBtn2">Jump to a topic</button>
    </div>
  </div></section>`;
  track.innerHTML=h;
  restore();
}

function restore(){
  document.querySelectorAll(".item").forEach(b=>{if(S.checks[b.dataset.c+"-"+b.dataset.k])b.classList.add("done")});
  Object.entries(S.answers).forEach(([c,o])=>mark(+c,o,false));
}

function mark(ci,o,animate){
  const c=GUIDE[ci-1], ok=o===c.quiz.a;
  document.querySelectorAll(`.opt[data-c="${ci}"]`).forEach(b=>{
    b.disabled=true; const v=+b.dataset.o;
    if(v===c.quiz.a)b.classList.add("right"); else if(v===o)b.classList.add("wrong");
  });
  const fb=document.getElementById("fb"+ci);
  fb.innerHTML=(ok?"<b>Correct.</b> ":"<b>Not quite.</b> ")+c.quiz.why; fb.classList.add("show");
}

function chapterDone(ci){return S.answers[ci]!==undefined}

let shown=-1;
function go(n,instant){
  n=Math.max(0,Math.min(total-1,n)); const moved=n!==shown; shown=n; S.pos=n; save();
  if(instant){track.style.transition="none";requestAnimationFrame(()=>track.style.transition="")}
  track.style.transform=`translateX(${-n*100}%)`;
  document.querySelectorAll(".screen").forEach((s,i)=>{s.classList.toggle("active",i===n); if(i===n){if(moved)s.scrollTop=0;s.removeAttribute("inert")}else s.setAttribute("inert","")});
  document.querySelectorAll(".screen").forEach((s,i)=>{if(Math.abs(i-n)>1)return;
    s.querySelectorAll("[data-bg]:not(.ready)").forEach(el=>{el.classList.add("ready");const u=el.dataset.bg,im=new Image();
      im.onload=()=>{el.style.backgroundImage=`url("${u}")`;el.classList.add("loaded")};im.src=u})});
  document.getElementById("prev").disabled=n===0;
  document.getElementById("next").disabled=n===total-1;
  document.getElementById("bar").style.width=(n/(total-1)*100)+"%";
  document.getElementById("crumb").textContent=n===0?"Store Manager Guide":n===total-1?"Complete":`${n}. ${GUIDE[n-1].title}`;
  document.getElementById("dots").innerHTML=Array.from({length:total},(_,i)=>`<i class="${i===n?"on":(i>0&&i<total-1&&chapterDone(i))?"seen":""}"></i>`).join("");
  if(n===total-1){
    const answered=Object.keys(S.answers).length, right=Object.entries(S.answers).filter(([c,o])=>GUIDE[c-1].quiz.a===o).length;
    document.getElementById("score").textContent=answered?`You got ${right} of ${GUIDE.length} quick checks right.`:"Come back any time to review.";
  }
  const sb=document.getElementById("startBtn");
  if(sb) sb.textContent=(S.pos>0||Object.keys(S.answers).length)?"Continue":"Start the guide";
}

function toc(){
  document.getElementById("toc").innerHTML=GUIDE.map((c,i)=>{const ci=i+1,d=chapterDone(ci);
    return `<button data-go="${ci}" class="${S.pos===ci?"cur":""}"><span class="n">${ci}</span>${esc(c.title)}<span class="st ${d?"ok":""}">${d?"✓ Done":""}</span></button>`}).join("");
}
const app=document.body;
function openMenu(){toc();app.classList.add("menu-open")}
function closeMenu(){app.classList.remove("menu-open")}

document.addEventListener("click",e=>{
  const g=e.target.closest("[data-go]"); if(g){closeMenu();go(+g.dataset.go);return}
  const it=e.target.closest(".item");
  if(it){it.classList.toggle("done");const k=it.dataset.c+"-"+it.dataset.k;if(it.classList.contains("done"))S.checks[k]=1;else delete S.checks[k];save();return}
  const op=e.target.closest(".opt");
  if(op&&!op.disabled){const ci=+op.dataset.c,o=+op.dataset.o;S.answers[ci]=o;save();mark(ci,o,true);go(S.pos);return}
});
document.getElementById("prev").onclick=()=>go(S.pos-1);
document.getElementById("next").onclick=()=>go(S.pos+1);
document.getElementById("menuBtn").onclick=openMenu;
document.getElementById("scrim").onclick=closeMenu;
document.getElementById("resetBtn").onclick=()=>{S={pos:0,checks:{},answers:{}};save();closeMenu();build();go(0)};
document.addEventListener("click",e=>{if(e.target.closest("#menuBtn2"))openMenu()});
document.addEventListener("keydown",e=>{if(e.key==="ArrowRight")go(S.pos+1);if(e.key==="ArrowLeft")go(S.pos-1);if(e.key==="Escape")closeMenu()});

// swipe
let sx=0,sy=0,dx=0,drag=false,lock=null;
const stage=document.getElementById("stage");
stage.addEventListener("scroll",()=>{if(stage.scrollLeft)stage.scrollLeft=0});
stage.addEventListener("touchstart",e=>{sx=e.touches[0].clientX;sy=e.touches[0].clientY;dx=0;drag=true;lock=null},{passive:true});
stage.addEventListener("touchmove",e=>{if(!drag)return;const x=e.touches[0].clientX-sx,y=e.touches[0].clientY-sy;
  if(lock===null&&(Math.abs(x)>8||Math.abs(y)>8))lock=Math.abs(x)>Math.abs(y)*1.3?"x":"y";
  if(lock!=="x")return; dx=x; track.style.transition="none";
  const edge=(S.pos===0&&dx>0)||(S.pos===total-1&&dx<0);
  track.style.transform=`translateX(calc(${-S.pos*100}% + ${edge?dx/3:dx}px))`},{passive:true});
stage.addEventListener("touchend",()=>{if(!drag)return;drag=false;track.style.transition="";
  if(lock==="x"&&Math.abs(dx)>stage.clientWidth*0.18)go(S.pos+(dx<0?1:-1));else go(S.pos)});

build(); go(S.pos,true);
</script>
</body>
</html>
