vibe-roast 0.98.3 → 0.98.4

package/README.md

@@ -2,9 +2,9 @@
 
 <div align="center">
   <img
-    src="./assests/characters-vibe-types/mpsf-builder/builder-figure.png"
-    width="190"
-    alt="Vibe Roaster Builder character"
+    src="./assests/readme/vibe-roast-16-types-banner.webp"
+    width="1100"
+    alt="All sixteen Vibe Roaster coding personalities gathered around the Vibe Roast title"
   />
 
   <h1>Vibe Roaster</h1>
@@ -53,11 +53,25 @@ Vibe Roaster reads supported local coding-agent histories, separates real user i
 
 The personality calculation is deterministic and local. AI writing is optional.
 
+<p align="center">
+  <a href="./media/promo/masters/landscape.mp4">
+    <img
+      src="./assests/readme/vibe-roast-promo-landscape.gif"
+      width="1100"
+      alt="Vibe Roaster turns prompt fragments into a four-axis personality verdict, one of sixteen characters, and a shareable roast"
+    />
+  </a>
+</p>
+
+<p align="center">
+  <sub>Watch the 15-second launch film · click for the 1080p version</sub>
+</p>
+
 <p align="center">
   <img
     src="./assests/screenshots/roast-result-hero.jpg"
     width="1100"
-    alt="Vibe Roaster result showing the Debugger coding personality, behavioral radar, and type axes"
+    alt="Vibe Roaster result showing the Builder personality, topic-aware hashtags, token statistics, behavioral radar, and type axes"
   />
 </p>
 
@@ -239,7 +253,7 @@ The writer cannot change the deterministic type. In one model call it produces:
 
 - three-beat English and Chinese roasts;
 - bilingual TL;DR punchlines;
-- 4–5 paired Hashtags with `en`, `zh`, semantic `kind`, and a short shared `meaning`.
+- five paired Hashtags with `en`, `zh`, semantic `kind`, and a short shared `meaning`.
 
 Hashtags are interpretations rather than frequency labels. Chinese is localized from the intended joke instead of translated word for word. Proper names, framework names, and meaningful acronyms may remain unchanged when translation would lose their identity.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-roast",
-  "version": "0.98.3",
+  "version": "0.98.4",
   "description": "Local-first AI coding personality profiler, usage dashboard, and evidence-grounded roast.",
   "type": "commonjs",
   "bin": {
@@ -32,7 +32,10 @@
     "worker/wrangler.jsonc",
     "worker/src/",
     "dashboard/dist/",
-    "assests/",
+    "assests/characters/",
+    "assests/characters-vibe-types/",
+    "assests/readme/",
+    "assests/screenshots/",
     "README.md"
   ],
   "scripts": {

package/src/lib/ai-roast.js

@@ -57,7 +57,8 @@ COMEDY ENGINE
 - Use a three-beat escalation: (1) a sharp cold open that casts the personality as a character, (2) a receipts paragraph with 2-4 evidence-backed details, and (3) an absurd-but-grounded escalation ending on the strongest punchline.
 - Sustain one concrete metaphor world—courtroom, kitchen, airport, laboratory, reality show, religion, heist, sports commentary, etc.—chosen to fit the evidence. Do not mix five unrelated metaphors.
 - Prefer specific nouns, active verbs, varied sentence rhythm, callbacks, contrast, and comic misdirection. One sentence may be dry; the next should twist the knife.
-- Mention at least one distinctive recurring domain concept when recurring_domain_concepts is non-empty. Treat it as a prompt mention, not proof of a project.
+- When recurring_domain_clusters is non-empty, choose the most semantically distinctive recognizable cluster as the preferred theme evidence. Do not mechanically choose the first or highest-salience row: salience measures repetition, not comic or semantic quality. Ignore identifier fragments, generic UI words, status prose, and operational boilerplate.
+- Otherwise mention at least one distinctive recurring domain concept when recurring_domain_concepts is non-empty. Treat it as a prompt mention, not proof of a project.
 - Use exact numbers selectively as "receipts"; never turn every sentence into a dashboard caption.
 - The final sentence must be a quotable punchline, not advice, diagnosis, or a generic summary.
 - English and Chinese should be locally funny adaptations using the same evidence beats, not stiff line-by-line translations.
@@ -66,14 +67,20 @@ COMEDY ENGINE
 
 HASHTAG ENGINE
 - Hashtags are interpretations, not a frequency table. Never copy a recurring concept merely because it ranks highly.
-- Read coherent concept clusters and infer the recognizable domain, community, scene, or character behind them. For example, preflop + folds + raises + river can become "HoldemPlayer"; 前庭 + HIT + nystagmus can become "VestibularLab" or "前庭实验室".
-- The first tag should be the strongest inferred domain/scene character when the evidence supports one. If it does not, lead with the personality character instead.
-- At least two tags should perform a semantic transformation: one domain/scene character and one coding-behavior joke. The remaining tags may reinforce personality or the central roast metaphor.
+- Read coherent concept clusters and infer the recognizable domain, community, scene, or playful fictional role behind them. For example, preflop + folds + raises + river can become "HoldemPlayer"; 前庭 + HIT + nystagmus can become "VestibularLab" or "前庭实验室"; Delta Force + bullet + price + market can become "AmmoBroker"/"弹药盘商" or the sharper "ArmsDealer"/"武器贩子". Examples demonstrate reasoning only; never copy an example unless the supplied evidence supports that exact scene.
+- Treat hashtags as stage names from a comedy writer's room, not cautious analytics labels. Bold exaggeration, slang, puns, subculture references, mock job titles, and slightly unhinged fictional roles are welcome.
+- A distinctive standalone recurring concept may inspire a fictional role even when it does not form a large cluster. Prefer a funny, recognizable interpretation over a technically exhaustive label.
+- Produce a varied set: usually include a domain/scene alter ego, a coding-behavior joke, the immutable personality title, and one or two wildcards tied to the roast metaphor or a memorable prop. Change the mix when the evidence offers a better joke.
 - Do not emit isolated raw keywords such as "preflop", "browser", "implementation", "debugging", or "UI" as tags. A proper name or acronym may remain literal only when it is already a meaningful identity label.
-- Generate every tag as one bilingual pair with a shared semantic gloss. The Chinese tag must localize the intended joke, not translate the English surface form word by word. "CodeCult" means cult-like devotion and should become "代码教团" or "代码邪教", never "代码文化".
+- Generate every tag as one bilingual pair with a shared semantic gloss. The Chinese tag must localize the intended joke, not translate the English surface form word by word.
 - When kind is "personality_character", reuse immutable_profile.personality and immutable_profile.personality_zh instead of inventing a new translation.
 - Use kind "proper_noun" only for names or acronyms that should remain unchanged in both languages, such as GitHub, HIT, or ONNX.
-- Infer only from a coherent cluster. Never fuse unrelated concepts into a fictional project, occupation, credential, or claim of ownership.
+- A hashtag may cast a cluster or distinctive recurring concept as an obviously fictional scene role, but it must not assert the user's real occupation, credential, project ownership, or offline conduct. "ArmsDealer" is a comic handle; "the user sells weapons" is a forbidden factual claim.
+- Never fuse unrelated concepts. Combine concepts only when recurring_domain_clusters explicitly shows that they repeatedly co-occurred.
+- Every tag needs a different job. Generic stems such as Prompt, Code, Context, Build, Architect, Guru, Master, Minimalist, Ninja, or Wizard are allowed when they complete a specific punchline (for example "CodeCult"); reject them only as bland filler such as "CodeMaster".
+- The best domain tag should be difficult to write without the supplied topic evidence. The behavior tag should turn a measured contradiction into a concrete prop, scene role, or consequence—not a workflow label.
+- Only the immutable personality tag may be a plain title. The other tags must contain a concrete scene, prop, social role, tension, or punchline.
+- Before returning, silently run a writer's-room test: if a tag could describe almost any developer, if two tags are synonyms, or if nobody would want to screenshot it, replace it with a stranger and more evidence-specific joke.
 
 ANTI-BLANDNESS
 - Avoid report voice and filler such as "You're a builder", "all about", "minor signal", "faint echo", "verification pending", "context is optional", "X master", or "the data suggests".
@@ -91,7 +98,8 @@ EVIDENCE RULES
 - A low testing/debugging signal means verification is under-observed in these prompts. It does not prove the code is wrong, untested elsewhere, or delegated to other people.
 - Treat category counts as observed prompt behavior, not objective engineering quality or completed work.
 - Concept occurrence_count means text mentions, never completed commits, pushes, tests, features, or other real-world actions. Call it a mention when citing it.
-- Aggregated concepts do not prove they belong to the same project. Never combine separate concepts into an invented app, bot, product, stack, or ownership claim. Say the prompts "orbit", "mention", or "cluster around" those concepts.
+- recurring_domain_clusters are aggregate same-prompt co-occurrence evidence, so their concepts may be interpreted together as a comic prompt-world.
+- Standalone aggregated concepts do not prove they belong to the same project. Never combine separate concepts unless recurring_domain_clusters links them; never turn either form into an invented app, bot, product, stack, real occupation, or ownership claim. Say the prompts "orbit", "mention", or "cluster around" those concepts.
 - Category ratios do not reveal execution order. Never say code shipped before verification, entered production, broke, contained bugs, or failed to run.
 - Do not turn implementation/testing/debugging prompt categories into completed implementation, shipping, testing, or debugging actions. Say "implementation-classified prompts", "testing signal", or "debugging mentions".
 - Do not quote or reconstruct raw prompts.
@@ -119,8 +127,9 @@ Before writing, silently select:
 2. the metaphor world;
 3. three evidence receipts;
 4. the closing callback.
+Then silently verify that every non-personality hashtag is specific, distinct, and entertaining.
 
-Return 4-5 hashtagPairs. Order them as: inferred domain/scene character, coding-behavior joke, personality character, then optional metaphor/callback tags.
+Return exactly 5 hashtagPairs. Do not force a rigid order. Lead with the most shareable tag. When recurring_domain_clusters is non-empty, at least one tag should transform its most distinctive semantically credible cluster into a recognizable scene character or clearly fictional role rather than repeat one of its terms. When only recurring_domain_concepts are available, a distinctive recurring concept may still inspire a playful alter ego.
 Each pair must express the same meaning in both languages. Tags must be compact semantic labels, not copied high-frequency words. English tags must be English except proper names/acronyms. Chinese tags must be a culturally natural localization of the meaning, not a dictionary translation of the English word shape.`;
 
 function endpoint(baseUrl) {
@@ -274,8 +283,8 @@ function cleanHashtagPairs(value) {
   const seenEn = new Set();
   const seenZh = new Set();
   for (const raw of value) {
-    const en = cleanTags([raw?.en], 24)[0];
-    const zh = cleanTags([raw?.zh], 12)[0];
+    const en = cleanTags([raw?.en], 32)[0];
+    const zh = cleanTags([raw?.zh], 16)[0];
     if (!en || !zh) continue;
     const enKey = en.toLowerCase();
     const zhKey = zh.toLowerCase();
@@ -291,7 +300,7 @@ function cleanHashtagPairs(value) {
       kind,
       meaning: cleanText(raw?.meaning, 80, { short: true }),
     });
-    if (pairs.length >= 5) break;
+    if (pairs.length >= 6) break;
   }
   return pairs;
 }
@@ -349,8 +358,8 @@ function validateRoastPayload(raw) {
   const paired = hashtagPairs.length >= 3;
   const result = {
     ...(paired ? { hashtagPairs } : {}),
-    hashtags: paired ? hashtagPairs.map((pair) => pair.en) : cleanTags(parsed?.hashtags, 24),
-    hashtagsZh: paired ? hashtagPairs.map((pair) => pair.zh) : cleanTags(parsed?.hashtagsZh, 12),
+    hashtags: paired ? hashtagPairs.map((pair) => pair.en) : cleanTags(parsed?.hashtags, 32),
+    hashtagsZh: paired ? hashtagPairs.map((pair) => pair.zh) : cleanTags(parsed?.hashtagsZh, 16),
     roast: paragraphize(cleanText(parsed?.roast, 1100)),
     roastZh: paragraphize(cleanText(parsed?.roastZh, 700)),
     tldr: cleanText(parsed?.tldr, 150, { short: true }),
@@ -392,7 +401,7 @@ async function generateAiRoast(evidence, {
     const request = requestForProvider(config, {
       apiKey,
       messages,
-      temperature: 0.9,
+      temperature: 1.05,
       maxTokens: 1800,
     });
     const response = await fetchImpl(request.url, {

package/src/lib/roast-evidence.js

@@ -5,6 +5,31 @@ function finiteNumber(value, fallback = 0) {
   return Number.isFinite(number) ? number : fallback;
 }
 
+const CLUSTER_NOISE_TERMS = new Set([
+  "again", "already", "ambient", "app", "attached", "automatically", "been",
+  "block", "browser", "cannot", "created", "current", "default", "dev", "doc",
+  "don", "evidence", "explicitly", "failed", "in-app", "master", "may", "new",
+  "opened", "proceed", "related", "reproduced", "saved", "sessions", "task",
+]);
+
+function dominantVariant(variants = new Map(), fallback = "") {
+  return [...variants.entries()]
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0] || fallback;
+}
+
+function isClusterNoiseTerm(value) {
+  const term = String(value || "").trim();
+  const normalized = term.toLowerCase();
+  return (
+    !term
+    || CLUSTER_NOISE_TERMS.has(normalized)
+    || /^[a-f0-9]{8,}$/i.test(term)
+    || /^\d+(?:ms|s|m|h|d)$/i.test(term)
+    || /^\d{4}[-_/]\d{1,2}(?:[-_/]\d{1,2})?/.test(term)
+    || /^\d[\w-]{10,}$/.test(term)
+  );
+}
+
 function categoryRows(categories = {}) {
   return Object.entries(categories)
     .map(([key, row]) => ({
@@ -55,7 +80,7 @@ function domainConceptRows(records = [], limit = 12) {
   }
 
   return [...concepts.values()]
-    .filter((row) => row.prompt_coverage >= 3)
+    .filter((row) => row.prompt_coverage >= 2)
     .map((row) => {
       const term = [...row.variants.entries()]
         .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0] || row.key;
@@ -70,6 +95,7 @@ function domainConceptRows(records = [], limit = 12) {
         ) / 1000,
       };
     })
+    .filter((row) => !isClusterNoiseTerm(row.term))
     .sort((a, b) => (
       b.salience - a.salience
       || b.prompt_coverage - a.prompt_coverage
@@ -79,6 +105,149 @@ function domainConceptRows(records = [], limit = 12) {
     .slice(0, limit);
 }
 
+function domainClusterRows(records = [], limit = 6) {
+  const concepts = new Map();
+  const pairs = new Map();
+
+  for (const record of records || []) {
+    const local = new Map();
+    for (const item of record?.concepts || []) {
+      if (!item?.key || item.kind === "category" || item.vibe) continue;
+      const key = String(item.key);
+      const localRow = local.get(key) || { key, score: 0, variants: new Map() };
+      for (const [term, rawCount] of Object.entries(item.variants || {})) {
+        const count = Math.max(0, finiteNumber(rawCount));
+        if (!term || count <= 0) continue;
+        localRow.score += count;
+        localRow.variants.set(term, (localRow.variants.get(term) || 0) + count);
+      }
+      local.set(key, localRow);
+    }
+
+    // Bound pair expansion for unusually dense prompts while retaining their
+    // strongest domain concepts. No raw prompt text enters this structure.
+    const rows = [...local.values()]
+      .filter((row) => row.variants.size)
+      .filter((row) => !isClusterNoiseTerm(dominantVariant(row.variants, row.key)))
+      .sort((a, b) => b.score - a.score || a.key.localeCompare(b.key))
+      .slice(0, 10);
+
+    for (const row of rows) {
+      const concept = concepts.get(row.key) || {
+        key: row.key,
+        prompt_coverage: 0,
+        variants: new Map(),
+      };
+      concept.prompt_coverage += 1;
+      for (const [term, count] of row.variants) {
+        concept.variants.set(term, (concept.variants.get(term) || 0) + count);
+      }
+      concepts.set(row.key, concept);
+    }
+
+    const keys = rows.map((row) => row.key).sort();
+    for (let left = 0; left < keys.length; left += 1) {
+      for (let right = left + 1; right < keys.length; right += 1) {
+        const pairKey = `${keys[left]}\u0000${keys[right]}`;
+        const pair = pairs.get(pairKey) || { left: keys[left], right: keys[right], prompt_coverage: 0 };
+        pair.prompt_coverage += 1;
+        pairs.set(pairKey, pair);
+      }
+    }
+  }
+
+  const strongPairs = [...pairs.values()]
+    .map((pair) => ({
+      ...pair,
+      cohesion: pair.prompt_coverage / Math.max(
+        1,
+        Math.min(
+          concepts.get(pair.left)?.prompt_coverage || 0,
+          concepts.get(pair.right)?.prompt_coverage || 0,
+        ),
+      ),
+    }))
+    .filter((pair) => pair.prompt_coverage >= 2 && pair.cohesion >= 0.45)
+    .sort((a, b) => (
+      (b.prompt_coverage * b.cohesion) - (a.prompt_coverage * a.cohesion)
+      || a.left.localeCompare(b.left)
+      || a.right.localeCompare(b.right)
+    ));
+
+  const pairByKeys = new Map(strongPairs.map((pair) => [
+    `${pair.left}\u0000${pair.right}`,
+    pair,
+  ]));
+  const candidates = new Set(strongPairs.flatMap((pair) => [pair.left, pair.right]));
+  const clusters = new Map();
+
+  function pairFor(left, right) {
+    const [first, second] = [left, right].sort();
+    return pairByKeys.get(`${first}\u0000${second}`);
+  }
+
+  for (const seed of strongPairs) {
+    const keys = [seed.left, seed.right];
+    while (keys.length < 6) {
+      const next = [...candidates]
+        .filter((key) => !keys.includes(key))
+        .map((key) => ({
+          key,
+          links: keys.map((member) => pairFor(key, member)),
+        }))
+        .filter((candidate) => candidate.links.every(Boolean))
+        .sort((a, b) => (
+          b.links.reduce((total, pair) => total + pair.prompt_coverage, 0)
+          - a.links.reduce((total, pair) => total + pair.prompt_coverage, 0)
+          || a.key.localeCompare(b.key)
+        ))[0];
+      if (!next) break;
+      keys.push(next.key);
+    }
+
+    const signature = [...keys].sort().join("\u0000");
+    if (clusters.has(signature)) continue;
+    const links = [];
+    for (let left = 0; left < keys.length; left += 1) {
+      for (let right = left + 1; right < keys.length; right += 1) {
+        links.push(pairFor(keys[left], keys[right]));
+      }
+    }
+    const promptCoverage = Math.min(...links.map((pair) => pair.prompt_coverage));
+    const cohesion = Math.min(...links.map((pair) => pair.cohesion));
+    const terms = keys.map((key) => {
+      const variants = concepts.get(key)?.variants || new Map();
+      return dominantVariant(variants, key);
+    }).map((term) => String(term).slice(0, 48));
+    clusters.set(signature, {
+      terms,
+      prompt_coverage: promptCoverage,
+      cohesion: Math.round(cohesion * 1000) / 1000,
+      salience: Math.round(
+        Math.log2(1 + promptCoverage) * cohesion * Math.min(4, terms.length) * 1000,
+      ) / 1000,
+    });
+  }
+
+  const ranked = [...clusters.values()]
+    .sort((a, b) => (
+      b.salience - a.salience
+      || b.prompt_coverage - a.prompt_coverage
+      || a.terms.join("\u0000").localeCompare(b.terms.join("\u0000"))
+    ));
+  const selected = [];
+  for (const cluster of ranked) {
+    const terms = new Set(cluster.terms);
+    const duplicatesExisting = selected.some((existing) => {
+      const overlap = existing.terms.filter((term) => terms.has(term)).length;
+      return overlap / Math.min(existing.terms.length, cluster.terms.length) >= 0.8;
+    });
+    if (!duplicatesExisting) selected.push(cluster);
+    if (selected.length >= limit) break;
+  }
+  return selected;
+}
+
 function dimensionRows(dimensions = []) {
   return (dimensions || []).map((dimension) => ({
     key: dimension.key,
@@ -145,7 +314,7 @@ function buildRoastEvidence(report = {}) {
   const summary = report.summary || {};
 
   return {
-    schema_version: 1,
+    schema_version: 2,
     immutable_profile: {
       type_code: vibe.type_code,
       personality: vibe.personality?.title,
@@ -160,6 +329,7 @@ function buildRoastEvidence(report = {}) {
       categories: categoryRows(categories),
       recurring_behavior_terms: conceptRows(report.word_frequencies, 12),
       recurring_domain_concepts: domainConceptRows(report.word_cloud_records),
+      recurring_domain_clusters: domainClusterRows(report.word_cloud_records, 12),
     },
     activity: {
       metric: activity.metric,
@@ -183,4 +353,9 @@ function buildRoastEvidence(report = {}) {
   };
 }
 
-module.exports = { buildRoastEvidence, buildContradictions, domainConceptRows };
+module.exports = {
+  buildRoastEvidence,
+  buildContradictions,
+  domainConceptRows,
+  domainClusterRows,
+};

package/src/lib/roast-snapshot.js

@@ -1,5 +1,5 @@
 const SNAPSHOT_VERSION = 1;
-const WRITER_PROMPT_VERSION = 3;
+const WRITER_PROMPT_VERSION = 6;
 
 function finite(value) {
   const number = Number(value);
@@ -15,6 +15,8 @@ function buildRoastSnapshot(evidence = {}) {
   const categories = evidence.prompt_behavior?.categories || [];
   const categoryTotal = categories.reduce((total, row) => total + Math.max(0, finite(row?.count)), 0);
   const concepts = [
+    ...(evidence.prompt_behavior?.recurring_domain_clusters || [])
+      .flatMap((cluster) => (cluster?.terms || []).map((term) => ({ term }))),
     ...(evidence.prompt_behavior?.recurring_domain_concepts || []),
     ...(evidence.prompt_behavior?.recurring_behavior_terms || []),
   ];

package/src/sources/codex.js

@@ -79,12 +79,40 @@ function extractCodexPrompt(obj) {
     nested?.content,
   ];
   for (const candidate of candidates) {
-    const text = normalizeWhitespace(textFromContent(candidate));
+    const text = normalizeWhitespace(stripCodexInjectedContext(textFromContent(candidate)));
     if (text) return text;
   }
   return "";
 }
 
+function stripCodexInjectedContext(value) {
+  let text = String(value || "");
+
+  // Desktop attachment/browser envelopes place the authored request after
+  // this marker. Prefer that explicit boundary so filenames, screenshots, and
+  // ambient browser state never become personality evidence.
+  const requestMarker = /^## My request for Codex:\s*$/gim;
+  const markers = [...text.matchAll(requestMarker)];
+  if (markers.length > 0) {
+    const marker = markers[markers.length - 1];
+    return text.slice((marker.index || 0) + marker[0].length).trim();
+  }
+
+  // Some client versions inject the same context blocks without the request
+  // marker. Strip only known machine-owned envelopes; preserve ordinary XML,
+  // Markdown, and user-authored instructions.
+  const injectedTags = [
+    "in-app-browser-context",
+    "recommended_plugins",
+    "environment_context",
+  ];
+  for (const tag of injectedTags) {
+    const block = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, "gi");
+    text = text.replace(block, " ");
+  }
+  return text.trim();
+}
+
 function extractCodexTokens(obj) {
   const payload = obj?.payload || {};
   const info =
@@ -215,6 +243,7 @@ function number(value) {
 module.exports = {
   inspectCodex,
   extractCodexPrompt,
+  stripCodexInjectedContext,
   extractCodexTokens,
   extractCodexTool,
   extractCodexUsageEvent,

package/assests/badges/01-builder/builder-badge.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 64 64" fill="none" aria-label="Builder SHIP — deploy first symbolic badge">
-  <rect width="64" height="64" rx="14" fill="#111821" stroke="rgba(255,255,255,0.08)" stroke-width="1"/>
-  <image x="4" y="4" width="56" height="56" preserveAspectRatio="xMidYMid meet" href="data:image/png;base64,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"/>
-</svg>

package/assests/badges/02-debugger/debugger-badge.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 64 64" fill="none" aria-label="Debugger HUNT — duck at midnight symbolic badge">
-  <rect width="64" height="64" rx="14" fill="#111821" stroke="rgba(255,255,255,0.08)" stroke-width="1"/>
-  <image x="4" y="4" width="56" height="56" preserveAspectRatio="xMidYMid meet" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAABFpElEQVR42u29eZxkaVnn+33ec04suVdVZlV1Ld3V9ArdTUM3NCq0rQLD4qjg6MBFFBFUvOiM48yoXJfxjveOI1fHqwiMisuouAziAlwEB8FmEYHeaLrpvbv2ysp9i+2c877P/HFOREZERkRGZmUjc31//aktMzIyqqPe3/ssv+f3gMdXA8L813cACiT5ryptvzZ/P8zHn84fIqiIDPG4jsc0/07v6Po7e/wjwvj/BV/d0LZftc/Hka0fb4dIx0M2P07vjzPg4wCqoKrbv3bV1vOIbPOkHp4APLaH5KeoeZ5EsgPZfeC3HNg+5KLbEE+v5xv2LEs7UQ36Zh6eADyGPWzaGQHoNqd3wOEUGXzzi2R00/09hj3L/rx7AvDYbczfdoNqfhgR6ZkGyNAHTzqfV7d+vXaF8Ax50/vo3hOAxx6df+n1+yzxHu6mzW9u2RJVaEdY3vykDsFHss1jetcePC14AvC4lCBgd2G06tZD2e8wbnPLS36QdVcvwycBngA8LrHot0eMoroDQpHW7a3t1XwZ7rX2qiP4aICv6v6zx/8C0YDsMiLQHX+t7ri4KLkAQbRPFOCjAR8BeOwRGcilEcmlElGva1/zn3RvYxcPTwA+/N9SWNP++oBeX7fj8FuEYb9ENP9+urVRKQNKDx6eADy2OfTao9WmfTsBSnutv/3gtSvyhi4i6g7KC9uUHlpE4NnAE4DHcKF2s3jWrQcYLrjWnuKdnhJh6SIf2Wthk7QpAX0dwBOAx67mAPa+NdDU9G8efN2DYoH0aAWq7wJ4AvDY2a05qIfeCquHUOfJsIyhgzUDMiBCkG3ISbwmwBOAx94KaLbT42vHQdahAgjZPK2De31dz6M9Wo7iewGeADx2H0bvRcTcDL+Hben1SgG2DCe1fUAHiQ7ahEQeeCGQxw5zf90ZYWyrxe9DBsPUCTZfk/aMGNqHijZrfXrpCiYPHwH8U68FbCfV7Xv4mxFA80d7d0E6PQV2eza7z7n2KyH4w+8jAI+9qQVI15ygbqPJ125tgeqenEsZUIfo14L0gYCPADx2MF/fa4hG2wZ0GOAH0H44W0Z+u7QAQwbWAvOIZPvOhD/8PgLw2KnufsiOQL8zq93P0+ca1h7SYhWlaeupA7/hYOWgeALwEYDH01srkO2u9HZFXk+tQA9psW5GDsPe5NLn4PvD7wnAY5e+gINOWGYKurXCv8UItMc8QHeq0JsJdEcpwyWbmXh4AvDFv97moD1PmA7p0CtDTBpq7xu852vszvm91NcTgMfTRwJ6CY6c0iPv1z7Th9o2JDRQHby1veDfNHwR0GMPOwHDnKndPqbDcXiLG3Cf5+h64DDfW3rMN3uq8BGAxzYbfFR6G3vIHtUVdpWra/cosWzvaaBtP/zh9wTgsc147oAYvVexT3Yo6d0JCe2mSCnbtCU9PAF47MQRSAcfQt1zV2HZ4kTUz0dgmKnFYV+nhycAjyFdf6RHP397h6EhSafrUOsO1YvaJ/LwEYAnAI+nQyk40EC005Jrt9uA5RK9AX0EgO8CeDx9Nt464BOdZqGD9wbIgPagbOMt2C4X9tJfHwF47FVXYJgef5/dgJcy2ac9pvj6Rh7a/2t9EdATgMcldAV2OkHY/oXDfvl2ofu2RUHxFmCeADyeljmA7Uig3bFHd1m828lr6jkY1BYB6IAIw5ODJwCPXVzHg6b2dn2o+5h47ihEGPIFqW8FegLw2Nkiz920B3madgf2vb33Isfw8ATg0ePAyVYRzbBS2qFVf3169yLsYD55Z9GJhycAjx1s7Rlan7tTafDAan3XotFcRCDb+ADIjs1NPTwBeHS173q08La4ewyoyA85mi95iCE913lt/UaDhnm0r63Y8ItOPPBCoH/y57/dvnubfX2DHHZ1KEv+zO9Pt0nad7KjQPLv5o+7jwA8LrUBIJJv1N2pZHew5790zPdLm/vwgHpdn0hhay1BB7YifSLgCcBjaDMQ3eLxP3BjcOtj2lPJR3tE0b44ZJgLfrutQtssA/TSYE8AHrucCNRdHp4Ow44e17v2igh2WdlvL1j6W94TgMce+wLsvouQRwOqfSvx2kYWMsS8gAwkCeltJ+ZTAE8AHjvz+Nch5LPDOvhKj0q89CCLDu+A1j4AGRiddHYqO7cVdXcvfQrgCcBjF/sAh5EF66DUXLZu9O3VK5Qe0QNob6OPbTqV2lZo9PAE4LHLboD2OdVDFe/6bfXpsvMa1AG41IWeXgOA1wF47Dz3113KfDsKh60awDY+ALqNL+EA84+9+Dt5+AjAg0vfoydDzO4PO3ik/Qp9OuBzfhbIE4DHV6YjINsYgG5d4Z0XGGV46fAmEWwKlHWAyIhdzgp4eALw2ENj0I5Boq58fEu4L/1TAGnfFJwXA7crPvZbJ9aLkDw8AXgMux9gBxbg27sFS98mvbSvEu81PSg7q+xfyjYjD08AXg3YNYY7rL5+i+NPn0We3ZuItIcMeYvT8FBLAcmFQdoqNHoi8ATgsUM573Y79bRjEq93uN1d6d+uiCdD5O3bRiU92gs+BfAE4LETZZ/uxOBDt+r6ZfuUQXsm7HvTulM/CegJwGN3YX8/x55+jCGyVfHXb95fthEY7NSOHG8RhhcCeezNGHCPfXrbKWo7vkb6GggNFYpvrhLTXZuYqhcBeQLw2GNnXh1W/XfpY4TDbBxW6SwcDpQM9+o1evgUwGPnqkDpP8uzownBofL2XDgk2xh99Bs17vYE7PAo8PAE4LED++62g9NRYO8a+NEePn3dObnIcNOGm8Ih2Womop0zB9qHfLRrpbkfDvIE4HHJhCBD5QbZ2d26J3DQGexVfNReKsAeLNJfFehvfV8D8LikqUBV3eL7N8y47l5duNqdy/cYJ24fFtItTUoPHwF47Dj/31ZDL+zYTmyLrZcM93jpwSYdqYk/5Z4APPZ4DkC3mQDUndmN0UP8M8jQsyPCkP4DRqr924K+7ucJwGMP2oG6g0Pez51H+rT8BpmGNj+vur3oZxBJte879PA1AI8dGnwM5xikuxQf6UAnYB1gK9RrzmDLPgL1KYKPADy2Hf7ZS8cguUR3nkE7CTYdf6V/etBH2ejhCcBjiHxehySLfhP3OtR8vuyYlERkc/SomVboV2bfgYcngH8awh8GD9e059WZW4/0H+2VzoacdjgB6zZ1gx525Kpb9gIMc9Ivxe/QwxPAP0kJsGwV4m016OhazNlhIiLS1ALRpgtiGHfhLa5EsqkH0F6mIl2va5gCoYcnAI8hJ+6GzenbF3LoAM9v6bMYUPrsHdjUAOnQ9Yvujce+C+AJwGMHOXK37r7DtEMGL+TQXotGtMeB3qYWIbvsXWr34pEepqQengA8BszX9/LvHLacv53l114V64atV3h4AvC4xO3A/VSC/YZz9uLsKbtbZ+ajfU8AHrvQAegAgw/tNyqs2tfXf5hdf7KlzbdHuww9PAF4DK8DkPbu/hAVs24Vn8j2U4K9TEW0j5pwO/nuIJMP7Sse8vAE4NHbOat1SLXnaI0MQSJD+wFqnyhEuk082klDup5PhvcPVB8heALwGEoJuCmh1aGHf/pN4XVLhLStr999eXe/hu60ZMthH3D4vTuwJwCPPawIigja1Utv99tD+uzlkF71Adm83aX/pNFeVPBFfFHQE4DHJZfhNT+xvTwCBk3bqbZFC7LVo0fbBAPdG4SHqUNIn0aE9vAv9PAE4LHLaUDpqvDvdOOubmP5LT3FQrotGQxrSe4NQT0BeOxgGlC26esP0gH01eD30uhLZ0dB9uAA+7veE4DHV0CA04892ucHtJcByBBjyO0twEs90ILfCYB3BPLY+z2CMpSD0LC382ZRUVrPZ2TwpuBhvrd6SyBPAB7DrwRnyP19243l6o6/f1YEdE4HOgLt1q/Q1wE8AXgMc7MPcPRpHqLx8XGmpqYYKZdz3z1tGX02e/8ibarCNnYRATGmRSLGBKyvrXHm7FlU4djRo0ztmyJuxFmuGBiC1uPBqescD+7aSZ4RiSFJGqyvrbO0vIy11r/BngA8tmOA7iigfQefU2VifJwrrzxBGIZsVKrUa/VWW0/zg9k0AzEAYrpUhmBMdkCtdVi1hEHI2toahw8cZLRY4uL6MqPj49QbDVAIAoMJDGo1O/wdQqVOumoefhEoRBHHjh3j8suPc+78eWZnL/r32MOjHXfccUcIcMMNN71jbHxMgST38Wn9MMYooJcfv1y/6Ru/QS8/frz1sb388Se/8Bt65+t/VSOM0vUaLuXH1ORk8uybbtKbbrjhHe1/Zw8fAXjkSJIG1117Hfd/6X6SOGldrCKCc46jR45w7bVXc/fd97C8toKIYSaaoBwUiTVFBKIgJGiaiDiHVYdTh2NzgWdEQGAMIYYRE1EPLI+sX+RNr/4uvvNrXk71kS/wczd/Jz/1xT/l6Mh+xqREzcYgQiCCMUKxWGCkWCQwBkOAGpDQYKIAp4JVh7Upi0tLnF1bYGV1lfUHH2RmehqAO++807/hngA82g/Do48+ytGjR7nmqqv58kMPEZhMruucUiqVuPLKE3z+C3extrbGaGmE68LDrDfqrLmYsdIYqVoKpshUaZIwCkEgIcWmltTGYISCBIgJMVZINWXSFPni7APcdO2N/Mqbfgp3cYPF2jo/fOJlfPzil/n47ANcO3qc0GRsFASGYlDg6OQhDu3fjwaCUSEwBoeyWl8nTS2pTVlJ1mnECc/ffw1PVeeYrS4xOzfn33BPAB70KfCdO3eOmZkZDh48yPz8PIUooBGnXHniBOfOX2BtbY0oCLmucIgL66uUpsb5f77pzRxjjDS1jAQFiiNFKIYEoUFFsUmKS1JSBFEhNVBwwmR5hLf+3W8QpVO8/yd/jZHFhLSaYBqW6mqdd97yZr75U/+ZebvGn7zypxkvFaklCaERnCh1UlweVYShICjaSKjXYjbWN4iKIb9rPs7HnryH5xy4BhG4UFkif6R/wz0BeLTDGIO1loXFRQ4dOsT8/ByKUi6V2Ld/P/fddx8InBg5yKn1eQ5Mz/DWl7+Os4sLLKSLrNTX+fAjd2GsEoUBBkMhCAkkQBQShcRZQKm4DX7w6pcQrjUwVln6wP2MrZTZiFIeu/gUNq4TjBQxKlw1fojVtSV+8XN/w3hQwjmLKljnaLgUlU2b8PnGMscmD3L7oWdhYsMrrn0h4yPjvO+BT/Cc6atRscxurHIH4JMATwAebShecYTq6fOsrqwwM3MQEUOcWGam9wNQrVYZL46wElcpTpb5V6/4Lhbnlnjt5V/DRFAmDmp85JG7OLu6RDEMiG1KYEKKJiKSAJFM+OnUsWFr/Nxd72N/cZQL63N838d+iQ89/98TVi2NWo2RcoGfffIveGzjPLeZ6/gPn34vNZtkBEDWOkzVUncxqdp8v4DhXLzALYev5Y1HvpH19QqfX3+SZx++mrgR85knH+C6I5czu/El8BTwVYHA/y/gq6ENYDh1ysn1V7xSV9dv02rDzRycMfPz8zjnGB8bY3RslAvnL3C4PEUhLPADL/p21jeqvHbiuZSqwkqyyls+8k5Ozs9SMgF1G+Ocw7oUa1PitEFiY9I0JnEJOMWpshrX2BeM8GT9IhfdKt929dfg6g3+ZOHz/NXcvRwPD1KNYxKXIggVW6NmYxo2wWqatx03lw1MBKPcffER4sBx6+RVXDa2n0raYGJqzK1W1s2F9aXPL8brf32CE+YUp5x/8/0sgEfzzQiC3AZcUacdMlqbpACkOK6dOIqppNy6/xqmk1HWTZ3v/+Q7uev8IxSDiEQtgQREJsjSCrE4caQ4UnFZBi5KKEIpCHHAdDjJn5z+LO+bu4v7gnl+8+zfcSQ8QIAhlQSLpaJ1LA5QVDItQCgBBRNSkJDQBIgqE+Eo73zgQ/z58ucZGSvzguPXUW00ODY1TS1p5CIFf/v7FMCj882IQmIyhZ4xncp7lxOCU1BrEXUUw4hkzPDWO3+Tu889ymWFfdRdjMmVfyIGUSgQsKI1AgIUwSLskxESUmLNagKhFNgXjPMzd70XMSHjZpyCRMSaoCixJoyZIjWXYIGChBgxCIYIQ4rNJglFiAg4FO7jv9z9F8xMTvHPTzyfUIVEHUVTaIY9ngR8BODRgYIggckm50ybKWibkUdiUxKX0kgTyqUyP3PXH/CF0w9zNDpAYlMUxeUVdqvKNeF+XlC+kplwAoslUcuYFHhGuJ9rohkMQmQCAoQD4QSBC3GxZcqM0NBMBpyoZV8wws3Fy7gxOkSoQkiAQxkRw7SUsPmcscEgIoTGMBGM8NN/93t89Px9FMICcWpxNKN+f/g9AXh0QFKFNBPuZCnA5mSeycnAqqOaNkjSlKW4ykNzJ5kJJ7NbHJNX4zO5bqwpTmCdBBWhRAFQRJQFt8G6JiSSYjVr5iUuZdKMcCAcR1FCCQgl6++Pmoh6GjNFiUgCAhEsjrpLuejWaWiCzWXMASY76KKsxzUeXL5A6MKsbuBS/0Z7AvDonY+51rBN59CcICZ7qyITAIaR0gi/9g9/ysn1ixSCIOutixBKSJiH5DExkRoeii9QsXVCycNwQizKY8kFYk1RVZxaVB11F9NwcRZ0aFZ/KErI+XSNp+wK66RMmRHWXB1UWdN6syqA4lr2g7FarDqmi5P86T0f5YsXHmM0LJE69W+0JwCPXgjKRSRX3Dnn2kigbdDGZL39UlCgulEhsgFOs/Xgh4MJVKGBJVbLc4JjLNgKq2mVQIUEx5XBNIfNJCftIoEYikQokGKp0iDCMCIRdU2wOJwqAUKBkBWt86Cd5US0nwNmhBSHFaUcFrmycIA1W2NNa4Byo5lhjAIlIpJGdutHBIT+X5wvAnr0EwJJmy9fpzWvOrdZDzACRimGRUICUhyHw1GOh5NM2RKJOCalTM0mnEvnKEsBJ8KkjHC9zPAFd4ZJKeNUsThCDIGG1CXl6vAAxgn3ufN5pyAbAQ6MoUyBmJTVpMrN4TE+Y58i1IjZZI2xaJrnlI7TwHKZGQcsl7lxTqZrFIMCoQlwDiIT5Xzmi4A+AvDofDNkM+TPyEC2+v0JOIHYptTjOqmmGIR122DBbnDRrREIxC7h4XSWSSljxFAQQ0NS1qRBIEE2JIRr+YapgOJYpc6qaWDVgmpW8BOT1xeUAiHL0uCUW6KoAREh41LiVLLEQrrGdFjmtF1hA8uc1lCUujaINcWKw/h/cT4C8OgvBSZ35Mn28/XOl0MT4FJLpV7FiaJqWdIGK3GNRC1zaYWboyNMSZkF3aCAoa6OKSkTi6XkQg5IgSfdMqGaVoFRMJxP11CUIC/+xeKIJAARTpgJ5mytNRW45mqMSAGLI1XH4cIkDzfmWLZV5myBgABQGppmUYxoS43o4SMAjy44XG7wL6jr7RQUmoDQBOCyKr2TzASkTFYLKEpEUSIetfMci/ZhEJZclQjDDKM8lMwy59Y4y1r+PXNHoDzPLxBSJKJEREgW/ieatR5P2nWWqDFrVylIwInoAKuuxppr8JzSUdQ5GjZlv4wQaHa7xC7B5sKmyBlGw4J/oz0BePQkgKRp6ZW18Xq5/hqRTOijYG1KopbJYITbwxPMmDEsSpEsxF+0Gzy/fCXPDo8wqSVO2mVCDCVCUMkOuQkyazABNQpGsWJJjENNRjgFiQgJaGiSvz7HPfFZ6pJyY/EoLyhezlRQ5HSyzKQpk4pyXWGGW0tHW5tBAjUEarIox8OnAB69Y4DN276zCOiaXn7551JnqcQ1AjFUSbhAhQpx9jkciVqmg1FEoGQinkqzMdwCIaExlMRQcXXmkmUaDJbkT1LiQGGKshRJXIJqJvg5HS/ygpFnMCIhqTqsUxomIcURi3ImXcOhWCw1FzMajJA6L//3BODRZxbAtO3c3VQCagdFZKO3dZuwUt9gMihTdwn3cQGjWQtxya3zjGgGjGE2WWfJbdCQlKKGOHFs2AYX3AoAlx07yguvfzY3X3EdRyanKVZSbD2hog3OVpd5eOEs9z3xEE+eOQ3AgWCMshQzMRClrAMQlKnamKuL05xLVtjQlIdqszhRShJRV0ODlFGj2DTxb7QnAI+e97+2THXzn7au5ZLc8LNp9RUQEAEhARbHutY4IhNMUOaL9bOZVl+ESTNChTrn4yUQeOU3vYTv/pqX8yI5zLFKCBsNuFiHlXVsNcEEE8j4Cez1X8+Z5yTcufgov3Pfx/jkl+4BNjgeTTNGiY20zmpaI1Fl2WxwTbCf9TQmyOXFJtcamHwVsVMvBPIE4NGnIJP14yS38G0t9ezyC88mBqWVDhjNlIIJjuuDQ4xIxIPpRUYloiARgcCy3eBiusILbrmV//DK7+XF8QyF+y5w/uK9/HXtAg805nm0tsSGi0mcY9KUuH5smhueOMRzRo/xPeUZvvWa7+ajV38jv/DFD3H/k49wPDrAmCnlA0WOdVfnJMtcGx7ktF1GEEJCAjFZsUkVnwB4AvDoqwMwbbu4tG+rMBCTdQo0SwmsKFYdV5sDRAQ8nMwxarJb1+GYT9dYthu87fvewk9c9VLGPv4kXzr7t7yv+ggfXH+CxyuL1JJ6DzqKKBcM147t51X7nslr5q7n2ycPc8dL/hU/f/pvefdH/pzpcJIJKeNwjBCx7mJmZZ3DMsGcVvINQ9LaSOx8DcATgMeAd0M0r5ybviu4mp2AZq/+kBnlWDjBqk14OJ4nEKFuEwJjWHUVKqbBu3/qP/GD1atZff/dvHPjft4++1nOrS0SUaBsQqJgNAs5RBEMQdZrIElS7lu6wH1L53jvxAP8+JV38C8euYZfueYVHP2OQ/z0+99Nw8SMSznTDyDMu3UOR6M8PzrCQ8kCmRthTnAengA8+tQAUpeF/mxd39uxDiw39NDc7DsCJqXIomlk4bYoAYZVrbChNd7zk7/ImxaO8NSnP8dPr36KPzp1NyMSsS8cw7nsWVzT2UcVUKy4rBBpYJIyBuHc2ho/fP8HuOeq2/jxSoN/d9n1xC/9bv7j3/wBQWAYlzJOoSiGNHBUNSE0hqo2SNRicVv0DR6eADyaBGC1bT13713hKhBIdkM3KWCVhEUSTiUrlEz2ljqjbMQ1fvb7/jVvnL+Mx/7H3/OWyif4+OzDTAcTNCfzm94BzcKj0+514pJpBHL3IKPw7sfv5NThRX699hLedsXNPPbcc/zxvR/nQGGcSEMaWOaTOoUw5EK8isFgNSMZ8W+zFwJ59EGa9gn7tSMaCExAJKZVZd/QBheSJRouIdHMpfdCvMBLv/Z2fvzYHZz/1H38aPWTfHz2YSZMmYYmxDZlPd3IQ/1mUTGTBctmpTGbPUJYTyvELqFGzLgp8+HZB/j5jc+SrKzw9hPfyPWHjnMxWSHK5waW0yqLaRVFc7cg19IPeHgC8KDPZtBW5V86ZcDaLgnODqmRAIAgV/XVqFPXBhftMkEp5Odf/j2M3HWK37MP8+ELDzIRZCq9iqvDSMjznvUcVtxGKwIQsgNq8nkEBFJn2dCY511zA1Vi6i5GBQ4EE7z39L38ef1JjlVCfvK6b2SDOuuulpEQjhDBunwnUU4soY8BPAF4DNIBbob7LUswNi3BBLCakuYHK8QQmYA0bwdacazbKt9y2zfwvLMFvnj2Cd55+h+YNOOEEgEwMTHJO1/zb/jMi9/GDzzvlay5Kk5cnn5IazrQqqOidX7y29/IZ176Nv7T87+DYpjJgo0IRY34pcfv5MnKEq8onODm/cc5ly6BZLMFThQjhpCA0Jj87+N1AJ4APOhb4u/4/WZ+vqkKVFLniF02ByAIdbWccatMmJHsABvhNVe9kOD+C/z2/D3MVpeIjMGIIbEp/+yGF/CG0RtZvuch3vWs7+CHXvitVFyd0AQEKtmEIFB1Dd72uh/kp/e9kLmHnuQnbvoWXnTkBuo2IcUSBPDA2jneN/cA+9cN33LoRjLLUChJxKqLKZmIshQomohADN4QzBOAx7Z5wKYLcHMOqGkQooCIyRyDyJZzOHWEKhRNRD1tcOzYUV5YvIzTlYv8+cqXMRjqLtsHMB6M8bF7Psd7Hv8E+48fYv7cOX7tWa/mh27/NlbsRrZExASs2Ro/84a38rNTL2Lhy48zM32AX33843x29jHGwhIu70YYDH829wDLcY2XlC8nCkJWbCXbS6hpllIgBJJtKvKzQJ4APAYd/fymb7cE03xkt/kY0wzTcyGQU4fFZeE/NV5w1Q0cTkt8QS8yW68wakoomVgoJaEW1/mhj/02f1D5MtOXTbMwN8uv3fTt/ODXfDOzdpm5dJWf+t9+iJ/efztzjz7BzPGDvOviZ/nRT/4OmtqsqJf7B0wEozxcXeSLdoGbygd55uRh1lwtbylmJiMu/1l8+u8JwGOIGkBXNqBOWxGBoojJXHoyV37J+wRKogkK3DBxDFmt8KV0HqcBBVNoiXCscxgjBFZ581+/m/evPszM6ATzT5zml5/1Kl570x38wLe8hrcdeCEX732YY4cu4w8v3se//tQfMCpFJI86MvPSbLlINY15uL7EVDjCDWOHcLjcZERwaDYp2Bxz9mJgvA7Ao08IYLsGANqjg/Y2gBLklmEBks8OGhLN8u/Lg3F0eZ1HqktZCzHXFjhAM6tfQgnRNOV7P/JuzIvfwqvLz2D+5Hl+/ZmvRqMCq/c/ztGZaf7gwj289VPvZb8Zw0k2htyMRpwoFsFpyulkDWMMx0vjHe1LzeXIqVrS/PV5+AjAo08I0Gr5uY7Wf1tHgFZ4HWSd+5wITIszRq2hUWkwH1cBi8W2cvbNJqJQNAVcCm/8xHt4/9qjlMpl6uvrNBYXGZsa5TcufI7v/+TvULCma5JPcivx7HUIIXUbA5ZyHmlovihE8u+nmqUgNvURgCcAj36mgD1zABFpHe+mcaizLpcNaN6205Z2INDs7rXOZjIcdbn1F3msIHm/3zAVjlJpVPlY5TRBEOSrvy1ihQ9deJAkTSiEJjcJpUM1iDbJJBv9RUGdtNUtcmlDblummpmV4DcDeQLw6P1mSK86QNtqMCPZNKA6h83z8VQzByCbh9i1eoOgGFEOCl1FxHyOIH/aoglZTFZ440u/g1+84VtZXlhgJBXKDVhfWeY9t7yel13zfBaSrDsASpsyIYtKRHEkKA6csmHjjgSgmS6IZoYH/v73BODRB9KU33VbgeumfCYQQyko5AU2l4f3jhSLy0eIL64vYSTguvJMR8i/OZbrEANzyQqvvuOV/Mo130Lt8bPsn5zi8+k897HE6MQodnWV3/m61/PSa25lLlnFSKbpbz2nSL5WzHE0HCOJ65xtrLU+3z5nkNkN+jaAJwCPvlBj2m76zUPfJgREREjFkuQLuUybfl/yt/OB1XNYtdxY2I8QZqaeEuTGHNn8wGpa4Ztuu513XP0qNh54lMmpMb6oK3zXF/6AN977xzw1klAeKWIvLPLbt7yW26+4gRW7sWlXIFkB0qihFJZ4Znk/S2mVL1fmCXJT0o4wJt9v6P/BeQLw6BcBmK024N1KQJd78GsuBDKY1nRgqNmv9y+fYUkSnj9yiCOlMazTvGAolEyBdVvjG17wIn7/lu8lvecJRsMy9zcWeM2n3oPUlPXVOq/92G9xMq0R1QU9tcgf3vx6bjtyLRVXpygRRoVQAqwqN44f5uaxwzzaWOTR9TnKEmHVtuoOWRog/p+bJwCPgRFA7geQl843D71u5tLZXI1pFfSyijyIy6y3p8woDy6c5ktugWtHZ7h96hirWmlW7Fi3VV74zFt5721vhvueZHxylPtZ5l98+j2sVjaIAkMUBjy6eo7v+MxvcLaYUAoLBEsb/Pfb3sAt+64kdpZAAkSFisa8cvpqDmnEZ9bPEduUMVPKw37paGOKkbYawB3+DfcE4NGvCii55Vez7ddqwUkmAgpMJrJ1OCIxrYLffjNOkqT8+ewXkTDiu6afg4ijqjGxptka77UKPHyeQ+MTfKm0znd+4XdYqKxSCENqmlB3DcaDMidX53jt3b/L0lSBmcn9hHE2JZSSqQHXXJWD5VG+rfwM1pOYDyw/SkBAWYoYMbkdmLZ8C1qmI4DvAngC8OhOAcIwK/61xABtZh3N4psIkQnzLcKQquVAMMIV4QGcZinBlIzx/tP3cE88x9eXr+A7LnsuDU2yLb8S8Q/nHub7HvgjPpSe57s/83usrm8wHpRJXJq7DWXfeSoY44mlC7zp7vfyabvAG+5+L/eunCIyWVuwoQnfd9nzuUYn+Xj9HJ9fPcOhYIIAg1HDiIStnkO2HyD3BPS1QE8AHr1mAdzmwdfO7kD7NKBKFk43U4BRIsZNgYZY6iSMBSUWauv80tlP4oD/88g3cN3EQSquQSG/oT9+4RFe84n/ynKlwkhYIsnlvc1bWjVrMU4F49w3+xSv+Mh/4dNzTzARlIgI2HB1Xnzoet409iyWiXn7ub8HhbIpEGNRUU4E+3KVAPlq0WwbsYcnAI9eSDPPPO0qAupmAABkKUBBAgoEWcCgmrkBkeb/OUZNiT8/fR9/Un+cy+0477rqW5kujVHXlFFTZCwoMR4Usq6C2pZCILfvaMUeFkfRhIwGEWUTUpKQNZtw64Fn8MsnXspMWOBdq/dy19pZ9oWj1DXNJL9CKw0wuVCoXc3o4QnAo08c0JTO9mIAk9/7QavxZ0hRNlyjbQgHxqRMKAFve/SDfELP8jyZ5o9veg3XTBxgyVYIyApyFteq0ouYlrQ4ay1mch7bjEzUcTFd45bpy/iNq1/BM1yZv6o9ydvPfIoRUyDI5xGMmNacQonMBwCyQqWHJwCPvm3AcPOWlK5BYdl069f84CakgFInzWYDNBPmNL900oyy0qjy5kffx93hAl83coQ/u+V1vOrym1hwVZbtBolLMSJEYjI/PzGELdvxjGDUKcu2wip1/uXxZ/Oe4y/j2nqJv1k/xVse+yBFIvaZMQI1FAiINaWIoeFS4qYleFM2bIw3BfIE4NF3FCCX/Wa3aG/TIKuOxFliLAIsuBqhBDzLHKKuad6jz27fY+F+FqsVXvfAf+dD609wTEf5jWMv53dv+HZeOH0lGihrtsqKrVG1CbG11G3Kuq2zYius2A1sZHnpZdfyRzd8J+/c/2IuSyJ+a+2LvP6x95NY5VAwSURIRIACkQm43kxz3q5R14QEi83rF/4fHH4c2IP+hgDNar+Rti1B0mYKqrnKTlomG3ViLto1poNxjusUF90GkQSEufjnWGE/52rLvPbe9/KWE1/LWydv5bsK1/DNV13F3ekcn66c4ssb85yrrlG1DRxKOQg4XprixvJBXjRxnNtKh5nQAl+qzfH2hU/zx7MPUpCQA2Ysa1kaOGTGSUUpBCH3JhdYdXUmgmx1WIIjkwV4CvAE4DHscMDWvQC5cafopnOwQ4kk4JRd4UAwwrVygFCFeapUiHFO2W/GWHEV3vXUZ/nI6KO88fAtfNvU1bywdIhvLB6iOmGpGUccKhoIRQcjDSjEUNeUR2oLfGD9MX7v/L1cqK2zPxijSISogIFQDAcKo8RpylpSZyOpMxYU84ZGU8dgWtOMHp4APPoIgURzT8BNJVBbUVBzq+1N+/CIgEIQUrCWJa1TkjFuNIe4255jg0aLPyZlhLKkPFlZ5Gee+B+8o/RZXjBxlFtHDnJNuI9D0ThjpRImMNQ0YT6ucv/6Rf5h/Sx/v3aajSRhghJXhjM4FRwWI1nBsu4STicrGAcrrsqElFqaArOpWfT5vycAj0HbgaW1BkQ7OwFtB97ky0ECMUS5RXeoBpc7/5ySNVaos08i1CliDAUinFhwcMCMY7Es1Wt8sP4IH+QRAIomoGxCDELDpVTcpodvgSzcL0kBEUMhMAhBZvnlMiejxXSdiBAVoWACRohYkDoRAZHJ5hRwm14CHp4APOiq9rfd+p0OQG2moCKEJhv+MSIkKJEYxsOQuaSKEeECayRS5rCM84RbzKf3sscHmm0VmjZR5iQkSqJZVyF1jlQVQ8h+U6RgQowKaW4qEhvLcrJBlbjjlU+aMhOmDC7rShwwJS5jnA0sqSRZd8N0GR96eALw6L0YoPPybysIar6/L/+jRRkxBQ4WxhhNQ5alxrrGRBjO6xolE/IM2c+i3VzVHRtLirZcelSzZaIBBRwOJ22bglw2PjwSRNRNymxjman94/zLV7+S5964n3qc8NnPPcFf/uXn2EjrTIcT4GBZ60xHYxRc2BpFFjHeFNQTgAd9mwCK9lgM2r5QJ7EpSZpkuXf++YZaqknMho2pYQlzOU+ZiCVXI8qTixDDpBSokLJKjEiQC4+yXN0pee+/fYzfUJQIjHCxPs8rv/l23vmrb+JE+QIsPgJREb7rdj76ult53Q/9ISsLaxwMpnAoj6WLlHInoVQdTp3fDegJwGO4IKD3duA4TUnTFGOEBgkNlxCTcrc9v2nSYQJUlYJmUt5Esg1CgRhq+eaezoGjrKtgpDMKcZIdWmccF+JlbnzOdfzZe99K+eSfwOkzUCgQr1VIkwYvu+44/+2XX8G3vel9VF2DcRlB1ZE6S6KOuk0opbGPALwQyGOIxUA9WoC5KWhureU0Gx1Kcbk3QPa5IL/piyagaCJGggJjpshIEFGUoOXKExohMIbABFlqYKRjM3AmN87MRmyQUncJP/bDr6S8+DckK7P8xf0FfuK/LdIoz1Dcf4TabIV/fpvjjhcdZcVWEcnUiimOhiYkLjcn9f/ifATg0ScFcK5rArCt9t+mA0g08/8LMRQJqUqDxXSVGIvJD27UMgrfdBJybZag2irGbxp1KsoYJQ5E40QaYHGcSVaoJw0KxQKPfukBHtlnuOqyUX707Z/h9Pk6L33+IV5yaxGXjKDJKl97c8gnPpFbmmlTstwcDhLU+QjAE4DHjgqC3ePAibMkzmLyycD5ZJWpmf1cdegwSRoTBAEmCFpFv/bugjrddOvVpmd/NoIYhhGnz55hbmWNKwoHOJcsc+uzRvieO57FrccmKC2e4jffs86P/9gJ/u/vv5J7HqvxvBNKulHBqIE4JtC01dI0rdUgkkmBjWQRgOcATwAevWYBNk1BO9oAuun5D1n4H7vMc2/ervKMEyf4y59/F0eKY9hKNd8dmGsK8iAgO/AOTTMyyDw788Q/yNyHSkHEPzz+RV71S29jKd2gqgmThTKvOlCnPLcC1RovJOGPPrzAv3nz5bx+I8ZVY6w1GGuR1SXuvXcOoLW52OQDQpExRCb0RUBPAB59U4BWtV+6PAA2twM3hUL5w1hzNW6bPsKNHIELi2AKkFpopJC4TSWhyeYLFDYPv83deQJBQwiMcPP4FYwUR0gbjsuDfXz4vmWee/8y//aZIc88EPHRM8J1N4Ct1misQ6EQoioUC5azpxf41H11xkxEopYEy5iUGZUiZRMRBSFREIDfEOYJwKNH/c86No8/Pa2zHA4DFIKAUANmgik+ef9d/OwH3sn1h46SuhQEXGqxiUWtbSX8YgRMHhXkw0fOWdQ61CqjUYm/+PLnWV1d40ThIIEK1wTTLFHn3z5UYUpqvOXl8Iav20AroxQLo6iAhBHVlXP8u3fOs7oGk6FyLl0GYIUaM4zmzsZk48BAZgrqfQE9AXhsHu60bf1Wl1y2fa+fESEKAgIJmAjKVJI6P/++39qz17EvGCXWBAFKWqQsAaVI+X9/8tl8z7NrLNc3QAVNYzQIIV3l5OMVKsFBJsdXWF2Peck3XcWPvOW5/NhPfIRTT62hOFKX5oPB+MPvCcCjdwtQWyUA6ZoBIN+zh4LaLJd3CgfCCaZkjMTZfFQ4qxmEbQ4/DpelAs2iYtvGEdXcCkw0m+5TJXYpgRjWpcaFeJn/+suv4Q0//DIa9/8FU8ki2ohRLBI3UBzX33yCD96+j0dmQ84vW77+tssJokU+88Ip3v7UBqmLidOEhov9LIAnAI+BHJAZ/XWeEemsAcRpJgDSfABI8gUcAYJqNlLYWs6TT+RlrsHZ47RlQpqRQXNGQEVBDC6/qWeTVW65aYYffPPXk37pLwkrF9CgkOv6LTIygUgJJwFpVblu/yrXzUD15AMUw5hnH81C/kaaMBJk5mKi/v7HC4E8trwZwWbfPnP93WwIqGtPBhR1mVefM0oqjhDDPlMm0RSRTAsQimmNF2fin2wjsDEGYzJlYCCZ9VeQLxYLNXciUlCTkcTtL7oe6ufQpUcQIkQdiEEmTiDl6Szi0JggVOKGob7SIIgMyfIcG2urOX+pb//5CMBjqMUgmoXpirQf+VYyYFp79gxOHQ2XcnPpGBEBkgjz6QYjpoBTGDcFnlWYZjGt8FS6mu8c1HwCgLxlmBl2NJuNVm3+uQxjI6CNVVCLaoxoAMYgtoGrrYGzqKaZyEeFQmmE9ZUlOH+eJy6Us39oxhCZgIIJUXwJ0EcAHvSyBJO2nL+neU5eTjdB0IoOLJaz6QoOpYGlIJkKUCRz6qmmMbHVlhKwmQoUTLZoVFujxtoS7gSaDROBYfbk40jtPFooYiKDBEJc20AbGwRBkOUtLncVLkRUN9ZYfPRxVAvc+WCSLzvNWoCB/yfnCcBj+1GAjjagtjnp5Oo9q5p5Aua3+EW7QQ1LzTYoSdTaFZyoZU1T5qnkHv2ZOi8h5XoOEKmhSowTbYmGQkw2wmsD9ptx/upv53ji7z6LzM1TqyRIWCQqjVJfmaO2Mo9LaqBKmliWzl/gqfseYiq0/NFdjs8/3mDMhKCZh0Fvq1MPnwJ4tF/wm3Ld1sxe++/ZVPALCIYxKTKqESEBkQQkatmvJQ6HUzxoLwJKqAbN6wWXyRSRCzkiEyxQpUDmBBQR0ZCUitZoqGU0CDizYnnDu1b4qx+LmDj7CJXlSdKgjHWOuFIjqdUoGMAmuDjmyumIjz4Y8uN/WmMyKBHYzIikYEIC8DoATwAeg9aDK9JpCNLmCLQ5yJPl8KJQICBBWdM6J6IDnE9XCMksuB5KLuLEYRASLIlLuT64jA0a3M0sqaatTWSBGEYpEpOSYlGxpNYxFZT5zBdrfNMvpPzH10bcfnwBaimxDSgUC0yWHKXQ0dCAk6tFfvnDjl/7/+oEScBMNMpq2kDyqUPr/HJQTwAe/W3BcyWgdDuCtO8GbG3Z1VaVX4DH7BJXRQe4xszw5fosDZJ8/DZbzFmVBs+Q/czrBrOsMSIR4kxrTjBVxwo1BCWQIKsHCEQu4rKgyMMP13jVz8VcfRxuOBIwMw4Hx2OiyLBUgYcvptz1mGV5VSkQMhaUSTTTIFgBFYP4VoAnAI8++X/LCbhzj550pwgdxZt8e48qBQJOJhkJ3FA+ymPxHGuuSiQhkvNLGISMO1i0mTeAiIG8/18m4gozxSm3wprWs4k+CbBicQ4OhiPEmvLUmTqPn7FNh8KO6kWBkH1BiHEBJnccsrhsMzCKtXghkCcAj54BgHWtfL95+3Ye+wyRZDJgkMywE2UiKDElZc6kKzzQuMDl4X6uCqe5Nz5DISeAUZRpKVMjIUTaaggZiWQ+vwGjpsi6bSAiOLUEanBGqatFFA4EpeyxRjLlYO4elDjFOiXQIDMbwRASEOSLTRJrsW1Owx6eADz6+AB0pv1t+4K1qQUwrbZegwShTDGMWI9rFE3EmWSJJSlSlgjrLBbHBCVO6SrLWiUwJtsj6JqFR6GO5TE3T4O05Q4USoDiiHIH4qZNmAXSVCliQCTXFCqREVSEEY1I870BeVMSzQ1NfSPAE4BH3xKAbnEE67QK2xQMaV4DcKpUaFCzJVK1lDTCYKhq5sE3agrcGB3hdGORZVfBiCHVrDDoRLGqhPlTpy0NgrbShlFTQlWpEGdfgzBuShwyo1hVFrSWrf7KHf+mTJmrzBTr1Dnt1kE1Fy9lpCU+B8DrADy2wLo0HwLqrAF01gPbJLytFeEwLkWKmi3ndLmiKJJMdXdF8QBrUuf60pEsJM87BA6IxDBhCi1H4qZWgNxEdEZGKBLQwOYinmzpx5FwnMuDqUx7QAKi+d4Bw6gpkGpCKSiQYrOOQk4wvgToCcCjb/Bv8jkg7bEXoHMsOMvXs7y9QEhZCyQu4Ug4xYZmCz5TTVGBRFP2aYmaxrggu4lNLikumJADMpJPGmbdAkWJNWVEChyWcTY0bt3gkWQNxjFX4t5kljN2KXP/1cx9ONWU/ZSIwiJn7Xq+FThbLJKqa3Mg9PAE4NGzDdjuANQK+9v+aFHSvLqueXV92VUpmiJHo0nGTRGrFhGhJBGnkxVm3TrjUiTWmIQUJ9nkYF1TFqSGE20VHhQIJaCmCU/JCk5ctq8wnyBokLJCjYYkFCVLNxTHhqtzgxykpgmfTc+y5hpEufQndZlFuIcnAA/69gH7iYLbZMFkMmDJ8veULJdf1zr3J2d5KllgnxmjKbo1ZNLec3aVeVflmeFlrGsNRLGipFieEU7j1CG5BLgsESGGaTPKjIyy7uqZVkAta67OhBSxRhEMo6ZIYAypKLcEx0kNPOoWGdco8yvAZa3Gll7BoD7/9wTg0QOp7VD8dawGaBMCWbU4zX5timsDNYxKkUQda65GQfKbF0fsUgzCXfFJEgM3lo7T0JQGCdcFhxmXEQIypZ4RYVOwK1weTDJpSiy5CitaZ8QUmDRlTqfLpGQGJIEI18k0TpQH7UVKhCT5LsGAAKeOghOKhGg+v+CB7wJ4bA0Ach1QRx1A2gggKxIIoYObpq9mZWU1t9222S0u0lozZhBChJhs4m/clHgoPs914UFuDI4gLpv9+1zyBGHu1ZctAc2q/efsKhd0lesLM0y7CUwgGCecSVcoSEiK43g0QVEFnPCF9AwTUiLWFCPZUhFQDk0c4PDoNBpbXK+cxsNHAB5AIYDAbDkgqrq5UEOVUAw2TfnfX/Bqpicmqdh6vngzG/VtYlQKHNZJJijlbJ8Jc1Qdi7IBITzu5hE12VixZpt8YiyJOAomwCksuAozpkxRDceDfQQaUJBs9ciUlmg4xxqNzFEoF/taHEYMc/Eq33PLK7hh/+WkLiUKAp8CeALwoGeLz2CCTHDTuSlYsda2Qn1jhDhyTNki/9dtr6MRpNRcg80vk9z3zxBISCpZWGFxiMCi1jggY1TVZlFGPlew6RSY/c6pI5KAdRczm27QsMqpdAUjQupSFOUpt4IJQuapMRIU8teQfb8zjXleffXX8Z0zz+NiZRkTBZgg9Je/JwCPfotBjDFZJb6jDyitPxuEIAxIC4altRWeGx3nP7/ge6lKAi7r/TeLhata4yk3T0Ubrd5+pAHr2uDLySwn08XMEFTASPYIbW3xzeYAVJWGs8zqBufcCmfTJWzu+a+qrGqNJ+0CglCQkJCAEVNkKVnjFVfcxr+/6lXUVqts2DppPnDk4QnAowPZaGxjfg1bTxAjOOc6nHoknxVObMqpxVnKI2VONeaYr6zxz8aexS9+7RuokqAumxVonyAI1RDm9YBIAkYoUJZ8WSjZQtG6S4g1pRQVKBYKmMCQkBKaTMgbarZBOOyIEjLnoIKafDGpoWQKLMTrvOzE8/mZZ70WSR1f2jjNWKHMYmONxCWIiB8G/ipB4P8XfBXgVO6xG8ev1PXqbaNjY25sdNQsLCwgQBSF7Nu/n4XFRdQ5GrUGi8kqRw5fxsn1Czx76gS3zVzFLUev5pPnH2QlrlB1DeouIdGUVB02Xyoaa0qillQtiWYzAqtpjSsmDvGth2+jKg32FUe4oXwUQ8BTtYsEYog1zb8mJXYJsUtINRP+NFxCzcWkOGppg2+95mv5pee+maIID1XP8vfLj1JJY/c3Jz9vJkujn19Nqn+dXz4+HMB3ATyaWKmAwujoCLV6HVAKYUit3gCUkVKJjUqFyWiUJ8+eZn9hnNuOP5PfP3Mn42Fm5JGYlEPlSQ6WJkly+W4xCCnl/fqGpliX7e1Tp6zFFRbtBj95y+v5rS9/gPuXThKYgAflLP/Hja9l5fEqNnVMRqME+T6BTVvxTDZsNUUUrChfqp5ivrHCux77IHUSimFEGER8+KFPcqgwxanagn+fPQF49IKqYoxhfHycM2fOYjQL/+M4ZmlxiX3797FRqTBnV7mmcJjHnzyJq6e8+NoXoDiCNORHnvNqDodTREawkq/lzguMASbTD6QpSZqAE6y17CtN8ccnP809cw9zWfEADZcwmyzz+6f+lp959muoNWoUwoAwMARBiAQGMbkvYd7vNxiswmyyzmqtSsPGHB7Zx8nKRT764N8zE47zRDJPrIl/o/lq3EHt8Y9LxNlY/zuuuOLyH47jOL1wYTaUtv1gIoZrrr6a+YV5lpaWKUcljsgUjSQmKkQUgyiX2mWHdLwwglGTzQK0xnEgbcSkNiVxKc5ZkMxMpJJUmQzLuKbNhxiqttGq7CuKEUNowtwtKCsYWnWbXcsmYWmKwxFIQLVRZzQscsGupFXbCIFfB34kv3y8OYCPADzuuOMO7rzzTp75zGdibcrp02c6Kv8iWVHwzNmzXHP1VYRBwPzCAk/ILEWJCBODizMDkYKElIOItdpKy+svUUuMzbeBZzP+mf+/y52FBYzhol3LIgbNpg0LJmTdVbOZA21fXSabkQWCazctlowUrLps14CB2XgFgHK5zMGD05w6dab1d/bwBPBPHs2DsLa2xtzcXLbuSzZVwdn6L6FarfLY409w5YkTjI2OMntxjmqtRqNtfKBKzMpX08yNhSiK2LdvipmZGSqVqn/DfQrg0YOIU+AdwA+LkAKhds8D5aRgTMChQwcZHxtDVUnStO2NlNZIcWvNmLS5CzfvcJGek4fa8hzOf5Z8gahz0FUExLnOfYZtz2XEEASGMAwxQUC9UU/nZi+GlWrVpwA+AvBgYDGw9yRwc2Owc5YLFy5w0RjK5TLlchkRk68U1+Zigc3oQTqni6TlPaxdg4dKR+jRzh7NzcLtJmWthSXadp00F5sKRiBJU+r1GvV6o5XOqHopoCcAj+HCs64DqW3Tgc45KpUKlUrlf5FQ0x9+TwAeO1oTJn0OTOsgiewoj5PNMt7TJslvBiG01w07Fpx6eALw2PmuwL4P6Dpa3WF8N6l0SfB2QgbtT90W8Q9MY/DDv/hZAI89qdaKdFdutXuPUJ/DL30Po0qfHYVsf7D7kYSHJwCPPRsT3izeZXU3Yef3q+7oUzrEs2qPguWwJOHhCcBjmyt/swCvXQeyc1RYnlby+ep8Lg9PAP//T/51+5CcIUtrrShCOteQ72V6ojtob3p4AvDYQdCuu1RwNRcLt7wFtDN8l704tOJvd08AHk97mKy7qKprRyQhA5+z7zaiPhFFsyDZucfQh/yeADz2RAU46FDutO8/iDaah7k/rUhfOtIhleaeCzwBeOzSI2A3gx2bewSG+x7aJ9yXASqB7V6aqnodgCcAj6/U9Jb2OHwybMrRo+AoIh36PXkaIxUPTwAeQ80G7IwpdEtksFWfL30aENoh+RtMQF7j7wnAY4+Lgd2Xqg4Iu7sPpujW9lwzze+e6NNtZgpEt3YmZbddCf/W4mcBPIYuBsoudX7afuNr/zy89ekBN7j2Gk1md1p/Hyf4CMBjwO04UOQru2sl9r21u76hXuLh7VUGyCIZf+97AvDYqfivhynHkG0/7RrNbQ78iLS1/Lo1AsMUDGVwSN9DWJRpBNRrAnwK4LFn4oCd3NLNHEB7i4a16/dbxn0HFPqkx3zwluEgkc6CooePADx2pwyUbeV5PX7btWZ8+2p+74hE+0QBHb3+rghg0zbMH35PAB57WwzU3te/DP40vecJ++TvQ4h7thCU+ElATwAeXzFnoPYbuXPSr7utt+kpIH3m+mWQNdmwEYP2mRT0QYAnAI/dm4HspIjY3dYbVhTcHRWo7MCpqO+wstcAeALw2LXcN1sK0j+G1u4rmI5NXT1Dfx0iPNchUgqRnboSeHgC8Nhd+D8ghpaeN/LwuoN+Vf/2nL5fJKJD1iXFi4DwbUCPoUZ39Sv0tdpnbLjjubS/1n8Y51/1CkAfAXjsxSyADC0gahYAhd0XGcW7/HgC8PhHrPTrZg4uO71Dm5s5hjjBHV2Ervy/f9YhQxNXc8eg5xJPAB47Wb7RFT5LW79ehrLr1i2twZ2M8Wqv6qB0UtUwwqKmEtGnAJ4APHar/JUubf2Qhb6dOvJonxciA2YRpMcC085ZBH/4PQF4XGIHoEeBL9fYbxflqw5h+imDU4RBUYIOKVLy8ATg8TRoBVQv3V9w0HO0dAi70TF4+Z8nAI9LEwI15+lly8HXr9hGHt2pWlHEt/48AXhc6oHrXg2209MsSOe0rjx9zsW91Is+AfAE4HGJxcAtYpsdeQNox5DP0H6CO5hTkCFFSZ4MPAF47HGiIMPOEwyz2msbWujo7Uu39bigXc1/6bucxMMTgMcleQVK1/iNtKy+ZOCh75cCtLcW++38UaXvCDCShSpNj8Fez+c7AvhZAI+9KcLpdlZd0kerrzvdQdBsAQ6+w1sLR3voiaW1dUh9JOAjAI/deufLwBXhPQ6+7m73QG+S0d35/XeJgPzh9wTgMUxvv8/H2uW5vdKCfm48/f7cLDJuJRbZUcFRelmMsdXD0KcBngA8hrxGZZtwX7usurSHg7h2mYHpNtOEm3MGuqNugfaoP2iPjUTeGdgTgMdOVoMPbwLcdwuIDLnIe5iH9K1F+IPtCcDj6a0B9Kqk9071ZVeefHIJu/8ysZH2faD62QBPAB47d/YZVO2XAeIfafcHlM40QXYp9+34WunK8ZWea8a3vlYfKXgC8Nj1+lzZgR9A+x/2vBLfNZ2ow64q9+ffE4DH7reAaZtoR/sODm2NJmSPVnXroOfR3hpFH/V7AvDY5Tqwbfv+TbGN9JkdkE13oX6uQ0N7BA74fXe60tH995vB8EpAj11FAbqNnr5pFy5DbAnuu3KsR3guAyr+wvCORD7r9xGAxx7WBrr1/kOF5tv18HV7e2/Z5QH30b+PADx22QXofWPvbE24dPhySk8zz50oEwUGLhjtXhGu+JFATwAee+q+s5vn6kUeOgzpbLN0pNehbxMGbKtq9PAE4DFEBLDXB2i76cJhSalnLaAf2fjT72sAHruLAHSHhTfZxq1nO5Vfr9Zdr/0C0qMF6OsBngA8nk6B0BCNde3hx58RQttAkAzaOMxQnYntbME9PAF47GFoIB02XAzl0be5AVhb/XltVxU9TQfYW4J5AvDYY1Ww9hoblr3ZwrNbY9BhUhlvCeYJwGMvOwLaXeFnyM3BMtywzy5u7O03FKmfCPQE4LGjBRsMIQmWnXxYB84F6KWMK2unB0Ffh2KvC/YE4LH96i7pZQe2TZggO2jd7dQ6XLZRCkrbWPBO24wengA8BobuuzHypKffv7TP8osMnetvOzgk/V2NfNDvCcBjDyYEZafTdTo4EugVjosMEQXIcK1D6fAu9DTgCcBj1zUB1b1Zt6XbGIQM8iXUAcIf2bYT4BMBTwAeT3+XYJcXbV+FoOwkn/e3vCcAj727/bW/4KdvyL7Li1ZbNQHZ4kA0PBmppwFPAB57kfC3K/d6dwukp7HHTk7g1sUiuiehut8K7AnA41LOf5vct6/Zh/Rf3skQG4J26uzDLq29febvCcDjafEGkD7Tej3q7SJbzLl1h4e0efAHzSLg/f/xfgAeex5C6zaioWYEIH2q7YPUd71Xi8mWQaFhdhJ4tZ+PADz2sPW3rTy3SxSkMlg0JEMIjlQ3h4q03/bhHunDIMGP+HqAJwCP4eXAMqw5Zx/NbT/DT73U9WQ6YFJRpG9NQX09wBOAx6VvB9JhzTt2UYUXdrcqrNeC0K3EJX5BiCcAj6E9AbW/UKdvga0rdehOJYZZ7iF9VpFdaoVf0Y5pQQ98EdBjZ5bc267i7r6B24p40sekY7sQfRgzzx25/fgcwEcAHnt7RoTdHVARb/XlAf8TPtLbXd4kunIAAAAASUVORK5CYII="/>
-</svg>