From 582bb052f73dc090bf4fb75d2ccdd05114a995b2 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:12:19 -0700
Subject: [PATCH 01/24] feat: add LoRA utility module for LoraManager
 integration (#52)

Detection, metadata reading, trigger word cache, and prompt injection
for ComfyUI-Lora-Manager. All functions return empty results when
LoraManager is not installed.
---
 py/lora_utils.py | 303 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 303 insertions(+)
 create mode 100644 py/lora_utils.py

diff --git a/py/lora_utils.py b/py/lora_utils.py
new file mode 100644
index 0000000..9e8c329
--- /dev/null
+++ b/py/lora_utils.py
@@ -0,0 +1,303 @@
+"""Utilities for LoraManager integration.
+
+Provides detection, metadata reading, and trigger word lookup for
+ComfyUI-Lora-Manager (https://github.com/willmiao/ComfyUI-Lora-Manager).
+
+All functions are safe to call when LoraManager is not installed — they
+return empty results rather than raising.
+"""
+
+import json
+import os
+import re
+import threading
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+try:
+    from ..utils.logging_config import get_logger
+except ImportError:
+    import sys
+
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from utils.logging_config import get_logger
+
+logger = get_logger("prompt_manager.lora_utils")
+
+# ── LoraManager detection ────────────────────────────────────────────
+
+_LORA_MANAGER_DIR_NAME = "ComfyUI-Lora-Manager"
+
+
+def find_comfyui_root() -> Optional[Path]:
+    """Walk upward from this file to find the ComfyUI root (contains main.py)."""
+    current = Path(__file__).resolve().parent
+    for _ in range(10):
+        if (current / "main.py").exists() and (current / "custom_nodes").exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def detect_lora_manager(custom_path: str = "") -> Optional[str]:
+    """Return the absolute path to ComfyUI-Lora-Manager if installed.
+
+    Args:
+        custom_path: User-provided override path. Checked first.
+
+    Returns:
+        Absolute path string, or None if not found.
+    """
+    # 1. User override
+    if custom_path:
+        p = Path(custom_path)
+        if p.is_dir() and _looks_like_lora_manager(p):
+            return str(p.resolve())
+
+    # 2. Auto-detect via custom_nodes
+    root = find_comfyui_root()
+    if root:
+        candidate = root / "custom_nodes" / _LORA_MANAGER_DIR_NAME
+        if candidate.is_dir() and _looks_like_lora_manager(candidate):
+            return str(candidate.resolve())
+
+    return None
+
+
+def _looks_like_lora_manager(path: Path) -> bool:
+    """Heuristic: does this directory look like a LoraManager install?"""
+    # Check for characteristic files
+    markers = ["__init__.py", "README.md"]
+    has_marker = any((path / m).exists() for m in markers)
+    # Check for characteristic subdirectories or module name
+    has_lora_ref = (
+        (path / "lora_manager").is_dir()
+        or (path / "py").is_dir()
+        or "lora" in path.name.lower()
+    )
+    return has_marker and has_lora_ref
+
+
+# ── Metadata reading ─────────────────────────────────────────────────
+
+
+def find_lora_directories(lora_manager_path: str) -> List[str]:
+    """Find directories that contain LoRA models (with .metadata.json files).
+
+    Searches common locations: the LoraManager extension dir itself,
+    and the ComfyUI models/loras directory.
+    """
+    dirs = set()
+    lm_path = Path(lora_manager_path)
+
+    # Check ComfyUI models/loras
+    root = find_comfyui_root()
+    if root:
+        models_loras = root / "models" / "loras"
+        if models_loras.is_dir():
+            dirs.add(str(models_loras.resolve()))
+
+    # Check for any .metadata.json in the LoraManager dir tree
+    # (some users store loras inside the extension)
+    for meta in lm_path.rglob("*.metadata.json"):
+        dirs.add(str(meta.parent.resolve()))
+
+    return sorted(dirs)
+
+
+def read_lora_metadata(metadata_path: Path) -> Optional[Dict]:
+    """Read and parse a single .metadata.json file.
+
+    Returns:
+        Parsed dict, or None on failure.
+    """
+    try:
+        with open(metadata_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError) as e:
+        logger.debug(f"Failed to read {metadata_path}: {e}")
+        return None
+
+
+def get_trigger_words_from_metadata(metadata: Dict) -> List[str]:
+    """Extract trigger words from a parsed LoraManager metadata dict."""
+    civitai = metadata.get("civitai", {})
+    if not civitai:
+        return []
+    words = civitai.get("trainedWords", [])
+    if isinstance(words, list):
+        return [w.strip() for w in words if isinstance(w, str) and w.strip()]
+    return []
+
+
+def get_model_name_from_metadata(metadata: Dict) -> str:
+    """Extract the model display name from metadata."""
+    # Try civitai model name first, then file_name, then fallback
+    name = metadata.get("model_name", "")
+    if not name:
+        civitai = metadata.get("civitai", {})
+        model = civitai.get("model", {})
+        name = model.get("name", "")
+    if not name:
+        name = metadata.get("file_name", "unknown")
+    return name
+
+
+def get_preview_image_from_metadata(
+    metadata: Dict, metadata_path: Path
+) -> Optional[str]:
+    """Find the preview image path for a LoRA from its metadata.
+
+    Returns:
+        Absolute path string to the preview image, or None.
+    """
+    lora_dir = metadata_path.parent
+    file_name = metadata.get("file_name", "")
+    if not file_name:
+        # Derive from metadata filename: "foo.metadata.json" -> "foo"
+        stem = metadata_path.name.replace(".metadata.json", "")
+        file_name = stem
+
+    base_name = Path(file_name).stem
+
+    # Check standard preview naming conventions
+    for ext in (".png", ".jpg", ".jpeg", ".preview.png", ".preview.jpg"):
+        candidate = lora_dir / f"{base_name}{ext}"
+        if candidate.exists():
+            return str(candidate.resolve())
+
+    return None
+
+
+def get_example_images_dir(lora_manager_path: str) -> Optional[str]:
+    """Find the LoraManager example_images directory."""
+    lm_path = Path(lora_manager_path)
+
+    # Direct subdirectory
+    candidate = lm_path / "example_images"
+    if candidate.is_dir():
+        return str(candidate.resolve())
+
+    # Search one level in user data dirs
+    for child in lm_path.iterdir():
+        if child.is_dir():
+            sub = child / "example_images"
+            if sub.is_dir():
+                return str(sub.resolve())
+
+    return None
+
+
+# ── Trigger word cache & injection ───────────────────────────────────
+
+_LORA_PATTERN = re.compile(r"<lora:([^:>]+):[^>]+>", re.IGNORECASE)
+
+
+class TriggerWordCache:
+    """Thread-safe cache mapping LoRA names to their trigger words.
+
+    Built lazily on first access, refreshable on demand.
+    """
+
+    def __init__(self):
+        self._cache: Dict[str, List[str]] = {}
+        self._lock = threading.Lock()
+        self._loaded = False
+
+    def load(self, lora_manager_path: str) -> int:
+        """Scan LoRA metadata files and build the trigger word mapping.
+
+        Returns:
+            Number of LoRAs with trigger words found.
+        """
+        new_cache: Dict[str, List[str]] = {}
+
+        lora_dirs = find_lora_directories(lora_manager_path)
+        for lora_dir in lora_dirs:
+            dir_path = Path(lora_dir)
+            for meta_file in dir_path.glob("*.metadata.json"):
+                metadata = read_lora_metadata(meta_file)
+                if not metadata:
+                    continue
+
+                words = get_trigger_words_from_metadata(metadata)
+                if not words:
+                    continue
+
+                # Key by filename stem (what appears in <lora:NAME:weight>)
+                file_name = metadata.get("file_name", "")
+                if file_name:
+                    stem = Path(file_name).stem
+                    new_cache[stem.lower()] = words
+
+                # Also key by the metadata file stem
+                meta_stem = meta_file.name.replace(".metadata.json", "")
+                if meta_stem.lower() not in new_cache:
+                    new_cache[meta_stem.lower()] = words
+
+        with self._lock:
+            self._cache = new_cache
+            self._loaded = True
+
+        logger.info(
+            f"Trigger word cache loaded: {len(new_cache)} LoRAs with trigger words"
+        )
+        return len(new_cache)
+
+    def get_trigger_words(self, lora_name: str) -> List[str]:
+        """Look up trigger words for a LoRA by name (case-insensitive)."""
+        with self._lock:
+            return self._cache.get(lora_name.lower(), [])
+
+    @property
+    def is_loaded(self) -> bool:
+        with self._lock:
+            return self._loaded
+
+    def clear(self):
+        with self._lock:
+            self._cache.clear()
+            self._loaded = False
+
+
+# Module-level singleton
+_trigger_cache = TriggerWordCache()
+
+
+def get_trigger_cache() -> TriggerWordCache:
+    return _trigger_cache
+
+
+def inject_trigger_words(text: str, cache: TriggerWordCache) -> Tuple[str, List[str]]:
+    """Scan text for <lora:NAME:WEIGHT> tags and append trigger words.
+
+    Args:
+        text: The prompt text potentially containing lora tags.
+        cache: Populated TriggerWordCache instance.
+
+    Returns:
+        Tuple of (modified_text, list_of_injected_words).
+        If no trigger words found, returns the original text unchanged.
+    """
+    if not cache.is_loaded:
+        return text, []
+
+    matches = _LORA_PATTERN.findall(text)
+    if not matches:
+        return text, []
+
+    all_words = []
+    for lora_name in matches:
+        words = cache.get_trigger_words(lora_name)
+        for w in words:
+            if w.lower() not in text.lower() and w not in all_words:
+                all_words.append(w)
+
+    if not all_words:
+        return text, []
+
+    injected = ", ".join(all_words)
+    return f"{text}, {injected}", all_words

From 4930d1fae7b83952ba8a139ada14b6a5ab2d2d80 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:12:24 -0700
Subject: [PATCH 02/24] feat: add IntegrationConfig for opt-in third-party
 integrations (#52)

---
 py/config.py | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/py/config.py b/py/config.py
index bea4b0d..360b2e2 100644
--- a/py/config.py
+++ b/py/config.py
@@ -201,6 +201,39 @@ def update_config(cls, new_config: Dict[str, Any]):
             cls.METADATA_EXTRACTION_TIMEOUT = performance["metadata_extraction_timeout"]
 
 
+class IntegrationConfig:
+    """Configuration for third-party extension integrations.
+
+    Manages opt-in integration settings for extensions like LoraManager.
+    All integrations are disabled by default so PromptManager works standalone.
+    """
+
+    # LoraManager integration
+    LORA_MANAGER_ENABLED = False
+    LORA_MANAGER_PATH = ""  # Auto-detected if empty
+    LORA_TRIGGER_WORDS_ENABLED = False  # Auto-inject trigger words into prompts
+
+    @classmethod
+    def get_config(cls) -> Dict[str, Any]:
+        return {
+            "lora_manager": {
+                "enabled": cls.LORA_MANAGER_ENABLED,
+                "path": cls.LORA_MANAGER_PATH,
+                "trigger_words_enabled": cls.LORA_TRIGGER_WORDS_ENABLED,
+            },
+        }
+
+    @classmethod
+    def update_config(cls, new_config: Dict[str, Any]):
+        lora = new_config.get("lora_manager", {})
+        if "enabled" in lora:
+            cls.LORA_MANAGER_ENABLED = lora["enabled"]
+        if "path" in lora:
+            cls.LORA_MANAGER_PATH = lora["path"]
+        if "trigger_words_enabled" in lora:
+            cls.LORA_TRIGGER_WORDS_ENABLED = lora["trigger_words_enabled"]
+
+
 class PromptManagerConfig:
     """Main configuration class for PromptManager core functionality.
 
@@ -274,6 +307,7 @@ def get_config(cls) -> Dict[str, Any]:
                 "auto_backup_interval": cls.AUTO_BACKUP_INTERVAL,
             },
             "gallery": GalleryConfig.get_config(),
+            "integrations": IntegrationConfig.get_config(),
         }
 
     @classmethod
@@ -389,6 +423,10 @@ def update_config(cls, new_config: Dict[str, Any]):
         if "gallery" in new_config:
             GalleryConfig.update_config(new_config["gallery"])
 
+        # Update integration config
+        if "integrations" in new_config:
+            IntegrationConfig.update_config(new_config["integrations"])
+
 
 # Load configuration on import
 try:

From c0bcce5af197309f880aa8d0bfb43394d463fffc Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:12:29 -0700
Subject: [PATCH 03/24] feat(api): add LoraManager integration endpoints (#52)

Detection, enable/disable, scan/import, trigger word lookup,
and cache refresh endpoints under /prompt_manager/lora/*.
---
 py/api/__init__.py         |   3 +
 py/api/lora_integration.py | 378 +++++++++++++++++++++++++++++++++++++
 2 files changed, 381 insertions(+)
 create mode 100644 py/api/lora_integration.py

diff --git a/py/api/__init__.py b/py/api/__init__.py
index 8d7af45..90d4695 100644
--- a/py/api/__init__.py
+++ b/py/api/__init__.py
@@ -24,6 +24,7 @@
 from .admin import AdminRoutesMixin
 from .logging_routes import LoggingRoutesMixin
 from .autotag_routes import AutotagRoutesMixin
+from .lora_integration import LoraIntegrationMixin
 
 try:
     from ...database.operations import PromptDatabase
@@ -99,6 +100,7 @@ class PromptManagerAPI(
     AdminRoutesMixin,
     LoggingRoutesMixin,
     AutotagRoutesMixin,
+    LoraIntegrationMixin,
 ):
     """REST API handler for PromptManager operations and web interface.
 
@@ -372,6 +374,7 @@ async def serve_js_static(request):
         self._register_admin_routes(routes)
         self._register_logging_routes(routes)
         self._register_autotag_routes(routes)
+        self._register_lora_routes(routes)
 
         # Register gzip compression middleware (once)
         global _gzip_registered
diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
new file mode 100644
index 0000000..6557057
--- /dev/null
+++ b/py/api/lora_integration.py
@@ -0,0 +1,378 @@
+"""LoraManager integration API routes for PromptManager."""
+
+import json
+import os
+from pathlib import Path
+
+from aiohttp import web
+
+
+class LoraIntegrationMixin:
+    """Mixin providing LoraManager detection, scanning, and trigger word endpoints."""
+
+    def _register_lora_routes(self, routes):
+        @routes.get("/prompt_manager/lora/detect")
+        async def lora_detect_route(request):
+            return await self.lora_detect(request)
+
+        @routes.get("/prompt_manager/lora/status")
+        async def lora_status_route(request):
+            return await self.lora_status(request)
+
+        @routes.post("/prompt_manager/lora/enable")
+        async def lora_enable_route(request):
+            return await self.lora_enable(request)
+
+        @routes.post("/prompt_manager/lora/scan")
+        async def lora_scan_route(request):
+            return await self.lora_scan(request)
+
+        @routes.get("/prompt_manager/lora/trigger-words")
+        async def lora_trigger_words_route(request):
+            return await self.lora_trigger_words(request)
+
+        @routes.post("/prompt_manager/lora/refresh-cache")
+        async def lora_refresh_cache_route(request):
+            return await self.lora_refresh_cache(request)
+
+    # ── Detection ────────────────────────────────────────────────────
+
+    async def lora_detect(self, request):
+        """Auto-detect LoraManager installation."""
+        try:
+            from ..lora_utils import detect_lora_manager
+
+            path = await self._run_in_executor(detect_lora_manager)
+            return web.json_response(
+                {
+                    "success": True,
+                    "detected": path is not None,
+                    "path": path or "",
+                }
+            )
+        except Exception as e:
+            self.logger.error(f"LoraManager detection failed: {e}")
+            return web.json_response({"success": False, "error": str(e)}, status=500)
+
+    # ── Status ───────────────────────────────────────────────────────
+
+    async def lora_status(self, request):
+        """Get current LoraManager integration status."""
+        try:
+            from ..config import IntegrationConfig
+            from ..lora_utils import detect_lora_manager, get_trigger_cache
+
+            config = IntegrationConfig.get_config()["lora_manager"]
+            cache = get_trigger_cache()
+
+            # Check if the configured path is still valid
+            detected_path = await self._run_in_executor(
+                detect_lora_manager, config.get("path", "")
+            )
+
+            return web.json_response(
+                {
+                    "success": True,
+                    "enabled": config["enabled"],
+                    "path": config["path"],
+                    "trigger_words_enabled": config["trigger_words_enabled"],
+                    "detected": detected_path is not None,
+                    "detected_path": detected_path or "",
+                    "trigger_cache_loaded": cache.is_loaded,
+                }
+            )
+        except Exception as e:
+            self.logger.error(f"LoraManager status check failed: {e}")
+            return web.json_response({"success": False, "error": str(e)}, status=500)
+
+    # ── Enable / Disable ─────────────────────────────────────────────
+
+    async def lora_enable(self, request):
+        """Enable or disable LoraManager integration and save to config.json."""
+        try:
+            data = await request.json()
+            enabled = data.get("enabled", False)
+            path = data.get("path", "")
+            trigger_words = data.get("trigger_words_enabled", False)
+
+            from ..config import IntegrationConfig, PromptManagerConfig
+            from ..lora_utils import detect_lora_manager, get_trigger_cache
+
+            # If enabling, validate the path
+            if enabled:
+                resolved = await self._run_in_executor(detect_lora_manager, path)
+                if not resolved:
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": "LoraManager not found at the specified path",
+                        },
+                        status=400,
+                    )
+                path = resolved
+
+            # Update in-memory config
+            IntegrationConfig.LORA_MANAGER_ENABLED = enabled
+            IntegrationConfig.LORA_MANAGER_PATH = path
+            IntegrationConfig.LORA_TRIGGER_WORDS_ENABLED = trigger_words
+
+            # Persist to config.json
+            config_dir = os.path.dirname(
+                os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            )
+            config_file = os.path.join(config_dir, "config.json")
+            PromptManagerConfig.save_to_file(config_file)
+
+            # Load trigger word cache if enabling
+            cache = get_trigger_cache()
+            if enabled and trigger_words and path:
+                count = await self._run_in_executor(cache.load, path)
+                self.logger.info(f"Trigger word cache loaded: {count} LoRAs")
+            elif not enabled:
+                cache.clear()
+
+            return web.json_response(
+                {
+                    "success": True,
+                    "enabled": enabled,
+                    "path": path,
+                    "trigger_words_enabled": trigger_words,
+                }
+            )
+        except Exception as e:
+            self.logger.error(f"LoraManager enable/disable failed: {e}")
+            return web.json_response({"success": False, "error": str(e)}, status=500)
+
+    # ── Scan LoRA example images ─────────────────────────────────────
+
+    async def lora_scan(self, request):
+        """Scan LoraManager metadata and import LoRA info + preview images.
+
+        Streams progress as SSE, matching the existing scan pattern.
+        """
+        try:
+            from ..config import IntegrationConfig
+            from ..lora_utils import (
+                find_lora_directories,
+                get_preview_image_from_metadata,
+                get_trigger_words_from_metadata,
+                get_model_name_from_metadata,
+                read_lora_metadata,
+            )
+
+            if not IntegrationConfig.LORA_MANAGER_ENABLED:
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": "LoraManager integration is not enabled",
+                    },
+                    status=400,
+                )
+
+            lm_path = IntegrationConfig.LORA_MANAGER_PATH
+            if not lm_path:
+                return web.json_response(
+                    {"success": False, "error": "LoraManager path not configured"},
+                    status=400,
+                )
+
+            response = web.StreamResponse(
+                status=200,
+                reason="OK",
+                headers={"Content-Type": "text/event-stream"},
+            )
+            await response.prepare(request)
+
+            async def send_progress(data):
+                line = f"data: {json.dumps(data)}\n\n"
+                await response.write(line.encode("utf-8"))
+
+            await send_progress(
+                {
+                    "type": "progress",
+                    "status": "Finding LoRA directories...",
+                    "progress": 0,
+                }
+            )
+
+            lora_dirs = await self._run_in_executor(find_lora_directories, lm_path)
+
+            # Collect all metadata files
+            meta_files = []
+            for d in lora_dirs:
+                dir_path = Path(d)
+                meta_files.extend(dir_path.glob("*.metadata.json"))
+
+            total = len(meta_files)
+            imported = 0
+            skipped = 0
+
+            await send_progress(
+                {
+                    "type": "progress",
+                    "status": f"Found {total} LoRA metadata files",
+                    "progress": 5,
+                    "total": total,
+                }
+            )
+
+            for i, meta_file in enumerate(meta_files):
+                metadata = await self._run_in_executor(read_lora_metadata, meta_file)
+                if not metadata:
+                    skipped += 1
+                    continue
+
+                model_name = get_model_name_from_metadata(metadata)
+                trigger_words = get_trigger_words_from_metadata(metadata)
+                preview_path = await self._run_in_executor(
+                    get_preview_image_from_metadata, metadata, meta_file
+                )
+
+                # Build prompt text from trigger words or model name
+                prompt_text = ", ".join(trigger_words) if trigger_words else model_name
+
+                # Build tags
+                tags = ["lora", f"lora:{model_name}"]
+                tags.extend(trigger_words)
+
+                # Save to database via existing mechanism
+                try:
+                    import hashlib
+
+                    prompt_hash = hashlib.sha256(
+                        prompt_text.strip().lower().encode("utf-8")
+                    ).hexdigest()
+
+                    existing = await self._run_in_executor(
+                        self.db.get_prompt_by_hash, prompt_hash
+                    )
+
+                    if existing:
+                        # Link preview image if we have one and it's not already linked
+                        if preview_path:
+                            await self._run_in_executor(
+                                self.db.link_image_to_prompt,
+                                existing["id"],
+                                preview_path,
+                            )
+                        skipped += 1
+                    else:
+                        prompt_id = await self._run_in_executor(
+                            self.db.save_prompt,
+                            prompt_text,
+                            "lora",  # category
+                            tags,
+                            None,  # rating
+                            None,  # notes
+                            prompt_hash,
+                        )
+
+                        if prompt_id and preview_path:
+                            await self._run_in_executor(
+                                self.db.link_image_to_prompt,
+                                prompt_id,
+                                preview_path,
+                            )
+
+                        if prompt_id:
+                            imported += 1
+                        else:
+                            skipped += 1
+
+                except Exception as e:
+                    self.logger.warning(f"Failed to import LoRA {model_name}: {e}")
+                    skipped += 1
+
+                # Progress update every 5 items or at the end
+                if (i + 1) % 5 == 0 or i == total - 1:
+                    progress = int(5 + (90 * (i + 1) / max(total, 1)))
+                    await send_progress(
+                        {
+                            "type": "progress",
+                            "status": f"Processing: {model_name}",
+                            "progress": progress,
+                            "processed": i + 1,
+                            "imported": imported,
+                            "skipped": skipped,
+                        }
+                    )
+
+            await send_progress(
+                {
+                    "type": "complete",
+                    "progress": 100,
+                    "total": total,
+                    "imported": imported,
+                    "skipped": skipped,
+                }
+            )
+
+            await response.write_eof()
+            return response
+
+        except Exception as e:
+            self.logger.error(f"LoRA scan failed: {e}")
+            return web.json_response({"success": False, "error": str(e)}, status=500)
+
+    # ── Trigger word endpoints ───────────────────────────────────────
+
+    async def lora_trigger_words(self, request):
+        """Look up trigger words for a specific LoRA name."""
+        try:
+            from ..config import IntegrationConfig
+            from ..lora_utils import get_trigger_cache
+
+            if not IntegrationConfig.LORA_MANAGER_ENABLED:
+                return web.json_response(
+                    {"success": False, "error": "LoraManager integration not enabled"},
+                    status=400,
+                )
+
+            lora_name = request.query.get("name", "")
+            if not lora_name:
+                return web.json_response(
+                    {"success": False, "error": "Missing 'name' query parameter"},
+                    status=400,
+                )
+
+            cache = get_trigger_cache()
+            if not cache.is_loaded:
+                lm_path = IntegrationConfig.LORA_MANAGER_PATH
+                if lm_path:
+                    await self._run_in_executor(cache.load, lm_path)
+
+            words = cache.get_trigger_words(lora_name)
+            return web.json_response(
+                {"success": True, "lora": lora_name, "trigger_words": words}
+            )
+        except Exception as e:
+            self.logger.error(f"Trigger word lookup failed: {e}")
+            return web.json_response({"success": False, "error": str(e)}, status=500)
+
+    async def lora_refresh_cache(self, request):
+        """Force-refresh the trigger word cache from disk."""
+        try:
+            from ..config import IntegrationConfig
+            from ..lora_utils import get_trigger_cache
+
+            if not IntegrationConfig.LORA_MANAGER_ENABLED:
+                return web.json_response(
+                    {"success": False, "error": "LoraManager integration not enabled"},
+                    status=400,
+                )
+
+            lm_path = IntegrationConfig.LORA_MANAGER_PATH
+            if not lm_path:
+                return web.json_response(
+                    {"success": False, "error": "LoraManager path not configured"},
+                    status=400,
+                )
+
+            cache = get_trigger_cache()
+            count = await self._run_in_executor(cache.load, lm_path)
+            return web.json_response(
+                {"success": True, "loras_with_trigger_words": count}
+            )
+        except Exception as e:
+            self.logger.error(f"Trigger cache refresh failed: {e}")
+            return web.json_response({"success": False, "error": str(e)}, status=500)

From 171a571a0d1908b839ccd03e674a9494d1e5ca5e Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:12:35 -0700
Subject: [PATCH 04/24] feat: inject LoRA trigger words into prompts at
 encoding time (#52)

When enabled, scans for <lora:NAME:WEIGHT> tags in prompt text and
appends trigger words from LoraManager metadata. Behind config toggle.
---
 prompt_manager.py      |  3 +++
 prompt_manager_base.py | 39 +++++++++++++++++++++++++++++++++++++++
 prompt_manager_text.py |  3 +++
 3 files changed, 45 insertions(+)

diff --git a/prompt_manager.py b/prompt_manager.py
index e8d904a..a1eceff 100644
--- a/prompt_manager.py
+++ b/prompt_manager.py
@@ -148,6 +148,9 @@ def encode_prompt(
             parts.append(append_text.strip())
         final_text = " ".join(parts)
 
+        # Inject LoRA trigger words if integration is enabled
+        final_text = self._inject_lora_trigger_words(final_text)
+
         # Use the combined text for encoding
         encoding_text = final_text
 
diff --git a/prompt_manager_base.py b/prompt_manager_base.py
index 9a393fc..43a6326 100644
--- a/prompt_manager_base.py
+++ b/prompt_manager_base.py
@@ -102,6 +102,45 @@ def _save_prompt_to_database(
             self.logger.error(f"Error saving prompt to database: {e}")
             return None
 
+    def _inject_lora_trigger_words(self, text: str) -> str:
+        """Append LoRA trigger words if integration is enabled.
+
+        Returns the text unchanged if the integration is disabled or
+        LoraManager is not installed.
+        """
+        try:
+            from .py.config import IntegrationConfig
+        except ImportError:
+            try:
+                from py.config import IntegrationConfig
+            except ImportError:
+                return text
+
+        if (
+            not IntegrationConfig.LORA_MANAGER_ENABLED
+            or not IntegrationConfig.LORA_TRIGGER_WORDS_ENABLED
+        ):
+            return text
+
+        try:
+            from .py.lora_utils import get_trigger_cache, inject_trigger_words
+        except ImportError:
+            try:
+                from py.lora_utils import get_trigger_cache, inject_trigger_words
+            except ImportError:
+                return text
+
+        cache = get_trigger_cache()
+
+        # Lazy-load cache on first use
+        if not cache.is_loaded and IntegrationConfig.LORA_MANAGER_PATH:
+            cache.load(IntegrationConfig.LORA_MANAGER_PATH)
+
+        modified, injected = inject_trigger_words(text, cache)
+        if injected:
+            self.logger.info(f"Injected trigger words: {', '.join(injected)}")
+        return modified
+
     def _generate_hash(self, text: str) -> str:
         """Generate SHA256 hash for the prompt text.
 
diff --git a/prompt_manager_text.py b/prompt_manager_text.py
index e10d146..6e0736c 100644
--- a/prompt_manager_text.py
+++ b/prompt_manager_text.py
@@ -142,6 +142,9 @@ def process_text(
             parts.append(append_text.strip())
         final_text = " ".join(parts)
 
+        # Inject LoRA trigger words if integration is enabled
+        final_text = self._inject_lora_trigger_words(final_text)
+
         # For database storage, save the original main text with metadata about prepend/append
         storage_text = text
 

From 062f430852dc18bd2b9420402944ce46101043f6 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:12:44 -0700
Subject: [PATCH 05/24] feat(ui): add LoraManager integration settings and
 import UI (#52)

Integrations section in settings with auto-detection badge, enable
toggle, trigger word toggle, and Import LoRA Data button.
---
 web/admin.html  |  43 +++++++++++++++
 web/js/admin.js | 141 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 184 insertions(+)

diff --git a/web/admin.html b/web/admin.html
index 05282d4..3fcb643 100644
--- a/web/admin.html
+++ b/web/admin.html
@@ -406,6 +406,49 @@ <h4 class="text-xs font-semibold text-pm-secondary mb-3 uppercase tracking-wide"
                         <p class="text-xs text-pm-muted mt-1">Choose how the Web UI opens from ComfyUI nodes.</p>
                     </div>
                 </div>
+
+                <!-- Integrations Section -->
+                <div class="border-b border-pm pb-3">
+                    <h4 class="text-xs font-semibold text-pm-secondary mb-3 uppercase tracking-wide">Integrations</h4>
+
+                    <div class="mb-3">
+                        <div class="flex items-center justify-between mb-2">
+                            <div class="flex items-center gap-2">
+                                <label class="block text-xs font-medium text-pm-secondary">LoraManager</label>
+                                <span id="loraDetectionBadge" class="text-[10px] px-1.5 py-0.5 rounded-full bg-pm-input text-pm-muted">checking...</span>
+                            </div>
+                            <label class="relative inline-flex items-center cursor-pointer">
+                                <input type="checkbox" id="loraEnabled" class="sr-only peer" disabled>
+                                <div class="w-8 h-4 bg-pm-input rounded-full peer peer-checked:bg-pm-accent transition-colors after:content-[''] after:absolute after:top-0.5 after:left-0.5 after:bg-white after:rounded-full after:h-3 after:w-3 after:transition-all peer-checked:after:translate-x-4"></div>
+                            </label>
+                        </div>
+
+                        <div id="loraSettings" class="hidden space-y-2 mt-2 pl-2 border-l-2 border-pm">
+                            <div>
+                                <label class="block text-xs font-medium text-pm-secondary mb-1">Path</label>
+                                <input type="text" id="loraManagerPath" readonly
+                                       class="w-full px-2.5 py-1.5 bg-pm-input border border-pm rounded-pm-sm text-pm text-[13px] text-pm-muted">
+                            </div>
+
+                            <div class="flex items-center justify-between">
+                                <label class="block text-xs font-medium text-pm-secondary">Auto-inject trigger words</label>
+                                <label class="relative inline-flex items-center cursor-pointer">
+                                    <input type="checkbox" id="loraTriggerWords" class="sr-only peer">
+                                    <div class="w-8 h-4 bg-pm-input rounded-full peer peer-checked:bg-pm-accent transition-colors after:content-[''] after:absolute after:top-0.5 after:left-0.5 after:bg-white after:rounded-full after:h-3 after:w-3 after:transition-all peer-checked:after:translate-x-4"></div>
+                                </label>
+                            </div>
+                            <p class="text-xs text-pm-muted">Automatically append trigger words when <code class="text-pm-accent">&lt;lora:name:weight&gt;</code> is detected in prompts.</p>
+
+                            <button id="loraImportBtn" type="button"
+                                    class="mt-1 flex items-center gap-1 text-xs text-pm-accent hover:text-pm-accent-hover">
+                                <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-8l-4-4m0 0L8 8m4-4v12"/>
+                                </svg>
+                                Import LoRA Data
+                            </button>
+                        </div>
+                    </div>
+                </div>
             </div>
 
             <div class="flex justify-end gap-2 mt-4">
diff --git a/web/js/admin.js b/web/js/admin.js
index 6437764..6e4cb9b 100644
--- a/web/js/admin.js
+++ b/web/js/admin.js
@@ -755,6 +755,7 @@
                 document.getElementById("webuiDisplayMode").value = this.settings.webuiDisplayMode;
                 this.renderScanPaths();
                 this.updateMonitoringStatus();
+                this.detectLoraManager();
                 this.showModal("settingsModal");
             }
 
@@ -776,6 +777,142 @@
                 }
             }
 
+            // ── LoraManager integration ──────────────────────────────
+
+            async detectLoraManager() {
+                const badge = document.getElementById("loraDetectionBadge");
+                const toggle = document.getElementById("loraEnabled");
+                const settings = document.getElementById("loraSettings");
+
+                try {
+                    // First check current status
+                    const statusRes = await fetch("/prompt_manager/lora/status");
+                    if (statusRes.ok) {
+                        const status = await statusRes.json();
+                        if (status.success && status.enabled) {
+                            badge.textContent = "enabled";
+                            badge.className = "text-[10px] px-1.5 py-0.5 rounded-full bg-green-500/20 text-green-400";
+                            toggle.checked = true;
+                            toggle.disabled = false;
+                            document.getElementById("loraManagerPath").value = status.path;
+                            document.getElementById("loraTriggerWords").checked = status.trigger_words_enabled;
+                            settings.classList.remove("hidden");
+                            this._loraPath = status.path;
+                            this._bindLoraEvents();
+                            return;
+                        }
+                    }
+
+                    // Try auto-detection
+                    const detectRes = await fetch("/prompt_manager/lora/detect");
+                    if (!detectRes.ok) return;
+                    const data = await detectRes.json();
+
+                    if (data.detected) {
+                        badge.textContent = "detected";
+                        badge.className = "text-[10px] px-1.5 py-0.5 rounded-full bg-blue-500/20 text-blue-400";
+                        toggle.disabled = false;
+                        document.getElementById("loraManagerPath").value = data.path;
+                        this._loraPath = data.path;
+                    } else {
+                        badge.textContent = "not installed";
+                        badge.className = "text-[10px] px-1.5 py-0.5 rounded-full bg-pm-input text-pm-muted";
+                        toggle.disabled = true;
+                    }
+
+                    this._bindLoraEvents();
+                } catch (e) {
+                    badge.textContent = "error";
+                    badge.className = "text-[10px] px-1.5 py-0.5 rounded-full bg-red-500/20 text-red-400";
+                }
+            }
+
+            _bindLoraEvents() {
+                if (this._loraBound) return;
+                this._loraBound = true;
+
+                const toggle = document.getElementById("loraEnabled");
+                const settings = document.getElementById("loraSettings");
+
+                toggle.addEventListener("change", () => {
+                    if (toggle.checked) {
+                        settings.classList.remove("hidden");
+                    } else {
+                        settings.classList.add("hidden");
+                    }
+                });
+
+                document.getElementById("loraImportBtn").addEventListener("click", () => {
+                    this.runLoraImport();
+                });
+            }
+
+            async saveLoraSettings() {
+                const enabled = document.getElementById("loraEnabled").checked;
+                const triggerWords = document.getElementById("loraTriggerWords").checked;
+                const path = this._loraPath || "";
+
+                try {
+                    const res = await fetch("/prompt_manager/lora/enable", {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            enabled,
+                            path,
+                            trigger_words_enabled: triggerWords,
+                        }),
+                    });
+                    const data = await res.json();
+                    if (!data.success) {
+                        this.showNotification(data.error || "Failed to save LoRA settings", "error");
+                        return false;
+                    }
+                    return true;
+                } catch (e) {
+                    this.showNotification("Failed to save LoRA settings", "error");
+                    return false;
+                }
+            }
+
+            async runLoraImport() {
+                const saved = await this.saveLoraSettings();
+                if (!saved) return;
+
+                this.showNotification("Scanning LoRA metadata...", "info");
+
+                try {
+                    const res = await fetch("/prompt_manager/lora/scan", { method: "POST" });
+                    const reader = res.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = "";
+
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) break;
+
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split("\n\n");
+                        buffer = lines.pop();
+
+                        for (const line of lines) {
+                            if (!line.startsWith("data: ")) continue;
+                            try {
+                                const data = JSON.parse(line.slice(6));
+                                if (data.type === "complete") {
+                                    this.showNotification(
+                                        `LoRA import complete: ${data.imported} imported, ${data.skipped} skipped`,
+                                        data.imported > 0 ? "success" : "info"
+                                    );
+                                    this.loadStatistics();
+                                }
+                            } catch (e) { /* skip malformed SSE */ }
+                        }
+                    }
+                } catch (e) {
+                    this.showNotification("LoRA import failed: " + e.message, "error");
+                }
+            }
+
             async saveSettings() {
                 const timeout = parseInt(document.getElementById("resultTimeout").value);
                 const displayMode = document.getElementById("webuiDisplayMode").value;
@@ -798,6 +935,10 @@
 
                     if (response.ok) {
                         const data = await response.json();
+
+                        // Save LoRA integration settings (fire-and-forget)
+                        await this.saveLoraSettings();
+
                         if (data.restart_required) {
                             this.showNotification("Settings saved. Restart ComfyUI for gallery path changes to take effect.", "warning");
                         } else {

From a2061e29777b53544aab50d2a76aadce622f4ef1 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:31:29 -0700
Subject: [PATCH 06/24] fix: detect LoraManager with case-insensitive directory
 scan (#52)

---
 py/lora_utils.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/py/lora_utils.py b/py/lora_utils.py
index 9e8c329..19023ab 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -57,12 +57,19 @@ def detect_lora_manager(custom_path: str = "") -> Optional[str]:
         if p.is_dir() and _looks_like_lora_manager(p):
             return str(p.resolve())
 
-    # 2. Auto-detect via custom_nodes
+    # 2. Auto-detect via custom_nodes (case-insensitive scan)
     root = find_comfyui_root()
     if root:
-        candidate = root / "custom_nodes" / _LORA_MANAGER_DIR_NAME
-        if candidate.is_dir() and _looks_like_lora_manager(candidate):
-            return str(candidate.resolve())
+        custom_nodes = root / "custom_nodes"
+        if custom_nodes.is_dir():
+            for entry in custom_nodes.iterdir():
+                if (
+                    entry.is_dir()
+                    and "lora" in entry.name.lower()
+                    and "manager" in entry.name.lower()
+                    and _looks_like_lora_manager(entry)
+                ):
+                    return str(entry.resolve())
 
     return None
 

From 1a6cad42cbbcbb5b4520b8e2df48ef3a43d2313d Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:42:05 -0700
Subject: [PATCH 07/24] fix: simplify LoraManager heuristic to match real
 install structure (#52)

---
 py/lora_utils.py | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/py/lora_utils.py b/py/lora_utils.py
index 19023ab..93fb32f 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -76,16 +76,12 @@ def detect_lora_manager(custom_path: str = "") -> Optional[str]:
 
 def _looks_like_lora_manager(path: Path) -> bool:
     """Heuristic: does this directory look like a LoraManager install?"""
-    # Check for characteristic files
-    markers = ["__init__.py", "README.md"]
-    has_marker = any((path / m).exists() for m in markers)
-    # Check for characteristic subdirectories or module name
-    has_lora_ref = (
-        (path / "lora_manager").is_dir()
-        or (path / "py").is_dir()
-        or "lora" in path.name.lower()
-    )
-    return has_marker and has_lora_ref
+    # Must have __init__.py (ComfyUI extension) or README.md
+    has_init = (path / "__init__.py").exists()
+    if not has_init:
+        return False
+    # Check for characteristic structure: py/ dir, or any .metadata.json nearby
+    return (path / "py").is_dir() or (path / "lora_manager").is_dir()
 
 
 # ── Metadata reading ─────────────────────────────────────────────────

From bff70b6323a7e511ff35019eaa08442763bea191 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 07:46:08 -0700
Subject: [PATCH 08/24] fix: find ComfyUI root via folder_paths and handle
 symlinked installs (#52)

---
 py/lora_utils.py | 41 ++++++++++++++++++++++++++++++++---------
 1 file changed, 32 insertions(+), 9 deletions(-)

diff --git a/py/lora_utils.py b/py/lora_utils.py
index 93fb32f..1c10f70 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -30,15 +30,38 @@
 
 
 def find_comfyui_root() -> Optional[Path]:
-    """Walk upward from this file to find the ComfyUI root (contains main.py)."""
-    current = Path(__file__).resolve().parent
-    for _ in range(10):
-        if (current / "main.py").exists() and (current / "custom_nodes").exists():
-            return current
-        parent = current.parent
-        if parent == current:
-            break
-        current = parent
+    """Walk upward from this file to find the ComfyUI root (contains main.py).
+
+    Tries both the resolved (real) path and the unresolved path to handle
+    symlinked custom_nodes installations.
+    """
+    start_paths = [Path(__file__).resolve().parent]
+
+    # If installed via symlink, the unresolved path leads through custom_nodes/
+    raw_path = Path(__file__).parent
+    if raw_path.resolve() != raw_path:
+        start_paths.append(raw_path)
+
+    # Also try via folder_paths if available (ComfyUI runtime)
+    try:
+        import folder_paths
+
+        base = Path(folder_paths.base_path)
+        if base.is_dir():
+            return base
+    except (ImportError, AttributeError):
+        pass
+
+    for start in start_paths:
+        current = start
+        for _ in range(10):
+            if (current / "main.py").exists() and (current / "custom_nodes").exists():
+                return current
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+
     return None
 
 

From 553d5c8dba95d09d678eb8f2864c1fb8ee8f2035 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:01:19 -0700
Subject: [PATCH 09/24] fix(ui): add pointer-events-none to toggle switch
 overlays (#52)

The styled div was intercepting clicks meant for the sr-only checkbox
input, preventing toggle switches from being clickable.
---
 web/admin.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/web/admin.html b/web/admin.html
index 3fcb643..ea58c47 100644
--- a/web/admin.html
+++ b/web/admin.html
@@ -419,7 +419,7 @@ <h4 class="text-xs font-semibold text-pm-secondary mb-3 uppercase tracking-wide"
                             </div>
                             <label class="relative inline-flex items-center cursor-pointer">
                                 <input type="checkbox" id="loraEnabled" class="sr-only peer" disabled>
-                                <div class="w-8 h-4 bg-pm-input rounded-full peer peer-checked:bg-pm-accent transition-colors after:content-[''] after:absolute after:top-0.5 after:left-0.5 after:bg-white after:rounded-full after:h-3 after:w-3 after:transition-all peer-checked:after:translate-x-4"></div>
+                                <div class="w-8 h-4 bg-pm-input rounded-full peer peer-checked:bg-pm-accent transition-colors pointer-events-none after:content-[''] after:absolute after:top-0.5 after:left-0.5 after:bg-white after:rounded-full after:h-3 after:w-3 after:transition-all peer-checked:after:translate-x-4"></div>
                             </label>
                         </div>
 
@@ -434,7 +434,7 @@ <h4 class="text-xs font-semibold text-pm-secondary mb-3 uppercase tracking-wide"
                                 <label class="block text-xs font-medium text-pm-secondary">Auto-inject trigger words</label>
                                 <label class="relative inline-flex items-center cursor-pointer">
                                     <input type="checkbox" id="loraTriggerWords" class="sr-only peer">
-                                    <div class="w-8 h-4 bg-pm-input rounded-full peer peer-checked:bg-pm-accent transition-colors after:content-[''] after:absolute after:top-0.5 after:left-0.5 after:bg-white after:rounded-full after:h-3 after:w-3 after:transition-all peer-checked:after:translate-x-4"></div>
+                                    <div class="w-8 h-4 bg-pm-input rounded-full peer peer-checked:bg-pm-accent transition-colors pointer-events-none after:content-[''] after:absolute after:top-0.5 after:left-0.5 after:bg-white after:rounded-full after:h-3 after:w-3 after:transition-all peer-checked:after:translate-x-4"></div>
                                 </label>
                             </div>
                             <p class="text-xs text-pm-muted">Automatically append trigger words when <code class="text-pm-accent">&lt;lora:name:weight&gt;</code> is detected in prompts.</p>

From d42fe477c32ff26e1e56d9f66e21232a69100107 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:03:51 -0700
Subject: [PATCH 10/24] fix: use lora-manager category and tag for imported
 LoRA data (#52)

---
 py/api/lora_integration.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index 6557057..1f215ab 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -232,7 +232,7 @@ async def send_progress(data):
                 prompt_text = ", ".join(trigger_words) if trigger_words else model_name
 
                 # Build tags
-                tags = ["lora", f"lora:{model_name}"]
+                tags = ["lora-manager", f"lora:{model_name}"]
                 tags.extend(trigger_words)
 
                 # Save to database via existing mechanism
@@ -260,7 +260,7 @@ async def send_progress(data):
                         prompt_id = await self._run_in_executor(
                             self.db.save_prompt,
                             prompt_text,
-                            "lora",  # category
+                            "lora-manager",  # category
                             tags,
                             None,  # rating
                             None,  # notes

From 8c93acb2cece966b45090e4ca346d9dee2ce8b52 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:08:01 -0700
Subject: [PATCH 11/24] fix: use rglob to find metadata in lora subdirectories
 (#52)

---
 py/api/lora_integration.py | 2 +-
 py/lora_utils.py           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index 1f215ab..f9d0e4f 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -201,7 +201,7 @@ async def send_progress(data):
             meta_files = []
             for d in lora_dirs:
                 dir_path = Path(d)
-                meta_files.extend(dir_path.glob("*.metadata.json"))
+                meta_files.extend(dir_path.rglob("*.metadata.json"))
 
             total = len(meta_files)
             imported = 0
diff --git a/py/lora_utils.py b/py/lora_utils.py
index 1c10f70..0811cd8 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -244,7 +244,7 @@ def load(self, lora_manager_path: str) -> int:
         lora_dirs = find_lora_directories(lora_manager_path)
         for lora_dir in lora_dirs:
             dir_path = Path(lora_dir)
-            for meta_file in dir_path.glob("*.metadata.json"):
+            for meta_file in dir_path.rglob("*.metadata.json"):
                 metadata = read_lora_metadata(meta_file)
                 if not metadata:
                     continue

From b71e4780e99b36dcfccfd6a886b721480c53acea Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:10:37 -0700
Subject: [PATCH 12/24] feat: discover LoRA dirs from extra_model_paths.yaml
 and folder_paths (#52)

Only models/loras under the ComfyUI root was checked. Now also parses
extra_model_paths.yaml and uses folder_paths.get_folder_paths('loras')
at runtime to find all configured LoRA directories.
---
 py/lora_utils.py | 57 ++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 53 insertions(+), 4 deletions(-)

diff --git a/py/lora_utils.py b/py/lora_utils.py
index 0811cd8..feafb17 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -113,27 +113,76 @@ def _looks_like_lora_manager(path: Path) -> bool:
 def find_lora_directories(lora_manager_path: str) -> List[str]:
     """Find directories that contain LoRA models (with .metadata.json files).
 
-    Searches common locations: the LoraManager extension dir itself,
-    and the ComfyUI models/loras directory.
+    Searches: ComfyUI models/loras, extra_model_paths.yaml lora dirs,
+    and the LoraManager extension dir itself.
     """
     dirs = set()
     lm_path = Path(lora_manager_path)
 
-    # Check ComfyUI models/loras
     root = find_comfyui_root()
     if root:
+        # Default models/loras
         models_loras = root / "models" / "loras"
         if models_loras.is_dir():
             dirs.add(str(models_loras.resolve()))
 
+        # Extra model paths from ComfyUI config
+        for extra_dir in _get_extra_lora_paths(root):
+            if extra_dir.is_dir():
+                dirs.add(str(extra_dir.resolve()))
+
+    # Also try folder_paths at runtime (catches all configured paths)
+    try:
+        import folder_paths
+
+        for p in folder_paths.get_folder_paths("loras"):
+            pp = Path(p)
+            if pp.is_dir():
+                dirs.add(str(pp.resolve()))
+    except (ImportError, AttributeError):
+        pass
+
     # Check for any .metadata.json in the LoraManager dir tree
-    # (some users store loras inside the extension)
     for meta in lm_path.rglob("*.metadata.json"):
         dirs.add(str(meta.parent.resolve()))
 
     return sorted(dirs)
 
 
+def _get_extra_lora_paths(comfyui_root: Path) -> List[Path]:
+    """Parse extra_model_paths.yaml for additional LoRA directories."""
+    results = []
+    for name in ("extra_model_paths.yaml", "extra_model_paths.yml"):
+        config_file = comfyui_root / name
+        if not config_file.exists():
+            continue
+        try:
+            import yaml
+
+            config = yaml.safe_load(config_file.read_text())
+            if not isinstance(config, dict):
+                continue
+            for section in config.values():
+                if not isinstance(section, dict):
+                    continue
+                base = Path(section.get("base_path", ""))
+                loras_val = section.get("loras", "")
+                if not loras_val:
+                    continue
+                for line in str(loras_val).strip().splitlines():
+                    line = line.strip()
+                    if not line:
+                        continue
+                    p = Path(line)
+                    if not p.is_absolute():
+                        p = base / line
+                    if p.is_dir():
+                        results.append(p)
+        except Exception as e:
+            logger.debug(f"Failed to parse {config_file}: {e}")
+    return results
+
+
 def read_lora_metadata(metadata_path: Path) -> Optional[Dict]:
     """Read and parse a single .metadata.json file.
 

From fea745deb9848fb073822236f1adf771066763e6 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:20:20 -0700
Subject: [PATCH 13/24] fix: use example prompts instead of trigger words,
 serve LoRA preview images (#52)

- Prompt text now uses civitai example prompts (images[].meta.prompt)
  when available, falling back to model name instead of trigger words
- Image serving now allows paths within LoRA directories when the
  integration is enabled, fixing 403 errors on preview images
---
 py/api/images.py           | 23 +++++++++++++++++++----
 py/api/lora_integration.py |  6 ++++--
 py/lora_utils.py           | 18 ++++++++++++++++++
 3 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/py/api/images.py b/py/api/images.py
index 0acdb4e..47c3fca 100644
--- a/py/api/images.py
+++ b/py/api/images.py
@@ -303,11 +303,26 @@ async def serve_image(self, request):
 
             image_path = Path(image["image_path"]).resolve()
 
-            # Validate path is within any configured output directory
-            output_dirs = self._get_all_output_dirs()
-            if output_dirs:
+            # Validate path is within any allowed directory
+            allowed_dirs = list(self._get_all_output_dirs())
+
+            # Also allow LoRA directories when integration is enabled
+            try:
+                from ..config import IntegrationConfig
+
+                if IntegrationConfig.LORA_MANAGER_ENABLED:
+                    from ..lora_utils import find_lora_directories
+
+                    lora_dirs = find_lora_directories(
+                        IntegrationConfig.LORA_MANAGER_PATH
+                    )
+                    allowed_dirs.extend(Path(d) for d in lora_dirs)
+            except Exception:
+                pass
+
+            if allowed_dirs:
                 allowed = any(
-                    image_path.is_relative_to(d.resolve()) for d in output_dirs
+                    image_path.is_relative_to(d.resolve()) for d in allowed_dirs
                 )
                 if not allowed:
                     return web.json_response(
diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index f9d0e4f..942012c 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -154,6 +154,7 @@ async def lora_scan(self, request):
             from ..config import IntegrationConfig
             from ..lora_utils import (
                 find_lora_directories,
+                get_example_prompt_from_metadata,
                 get_preview_image_from_metadata,
                 get_trigger_words_from_metadata,
                 get_model_name_from_metadata,
@@ -228,8 +229,9 @@ async def send_progress(data):
                     get_preview_image_from_metadata, metadata, meta_file
                 )
 
-                # Build prompt text from trigger words or model name
-                prompt_text = ", ".join(trigger_words) if trigger_words else model_name
+                # Build prompt text: prefer example prompt, then model name
+                example_prompt = get_example_prompt_from_metadata(metadata)
+                prompt_text = example_prompt or model_name
 
                 # Build tags
                 tags = ["lora-manager", f"lora:{model_name}"]
diff --git a/py/lora_utils.py b/py/lora_utils.py
index feafb17..bdc2b4a 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -208,6 +208,24 @@ def get_trigger_words_from_metadata(metadata: Dict) -> List[str]:
     return []
 
 
+def get_example_prompt_from_metadata(metadata: Dict) -> Optional[str]:
+    """Extract an example prompt from civitai image metadata.
+
+    Looks at civitai.images[].meta.prompt for the first available example.
+    """
+    civitai = metadata.get("civitai", {})
+    images = civitai.get("images", [])
+    for img in images:
+        if not isinstance(img, dict):
+            continue
+        meta = img.get("meta")
+        if isinstance(meta, dict):
+            prompt = meta.get("prompt", "")
+            if isinstance(prompt, str) and prompt.strip():
+                return prompt.strip()
+    return None
+
+
 def get_model_name_from_metadata(metadata: Dict) -> str:
     """Extract the model display name from metadata."""
     # Try civitai model name first, then file_name, then fallback

From 7713cecba6336dd930b04c4c3ef174e8f1a43836 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:24:45 -0700
Subject: [PATCH 14/24] fix: handle null civitai field, link all preview images
 (#52)

- Guard against civitai: null in metadata (was crashing the scan)
- Link all local preview images per LoRA, not just the first
- Add get_civitai_image_urls() for future remote image support
---
 py/api/lora_integration.py | 25 ++++++++-------
 py/lora_utils.py           | 63 ++++++++++++++++++++++++++++----------
 2 files changed, 58 insertions(+), 30 deletions(-)

diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index 942012c..f5f910f 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -155,7 +155,7 @@ async def lora_scan(self, request):
             from ..lora_utils import (
                 find_lora_directories,
                 get_example_prompt_from_metadata,
-                get_preview_image_from_metadata,
+                get_preview_images_from_metadata,
                 get_trigger_words_from_metadata,
                 get_model_name_from_metadata,
                 read_lora_metadata,
@@ -225,8 +225,8 @@ async def send_progress(data):
 
                 model_name = get_model_name_from_metadata(metadata)
                 trigger_words = get_trigger_words_from_metadata(metadata)
-                preview_path = await self._run_in_executor(
-                    get_preview_image_from_metadata, metadata, meta_file
+                preview_paths = await self._run_in_executor(
+                    get_preview_images_from_metadata, metadata, meta_file
                 )
 
                 # Build prompt text: prefer example prompt, then model name
@@ -250,12 +250,12 @@ async def send_progress(data):
                     )
 
                     if existing:
-                        # Link preview image if we have one and it's not already linked
-                        if preview_path:
+                        # Link all preview images
+                        for pp in preview_paths:
                             await self._run_in_executor(
                                 self.db.link_image_to_prompt,
                                 existing["id"],
-                                preview_path,
+                                pp,
                             )
                         skipped += 1
                     else:
@@ -269,14 +269,13 @@ async def send_progress(data):
                             prompt_hash,
                         )
 
-                        if prompt_id and preview_path:
-                            await self._run_in_executor(
-                                self.db.link_image_to_prompt,
-                                prompt_id,
-                                preview_path,
-                            )
-
                         if prompt_id:
+                            for pp in preview_paths:
+                                await self._run_in_executor(
+                                    self.db.link_image_to_prompt,
+                                    prompt_id,
+                                    pp,
+                                )
                             imported += 1
                         else:
                             skipped += 1
diff --git a/py/lora_utils.py b/py/lora_utils.py
index bdc2b4a..6bd4e80 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -197,11 +197,14 @@ def read_lora_metadata(metadata_path: Path) -> Optional[Dict]:
         return None
 
 
+def _get_civitai(metadata: Dict) -> Dict:
+    """Safely get the civitai dict, handling None values."""
+    return metadata.get("civitai") or {}
+
+
 def get_trigger_words_from_metadata(metadata: Dict) -> List[str]:
     """Extract trigger words from a parsed LoraManager metadata dict."""
-    civitai = metadata.get("civitai", {})
-    if not civitai:
-        return []
+    civitai = _get_civitai(metadata)
     words = civitai.get("trainedWords", [])
     if isinstance(words, list):
         return [w.strip() for w in words if isinstance(w, str) and w.strip()]
@@ -213,8 +216,8 @@ def get_example_prompt_from_metadata(metadata: Dict) -> Optional[str]:
 
     Looks at civitai.images[].meta.prompt for the first available example.
     """
-    civitai = metadata.get("civitai", {})
-    images = civitai.get("images", [])
+    civitai = _get_civitai(metadata)
+    images = civitai.get("images", []) or []
     for img in images:
         if not isinstance(img, dict):
             continue
@@ -226,43 +229,69 @@ def get_example_prompt_from_metadata(metadata: Dict) -> Optional[str]:
     return None
 
 
+def get_civitai_image_urls(metadata: Dict) -> List[str]:
+    """Extract all civitai example image URLs from metadata."""
+    civitai = _get_civitai(metadata)
+    urls = []
+    for img in civitai.get("images", []) or []:
+        if not isinstance(img, dict):
+            continue
+        url = img.get("url", "")
+        if isinstance(url, str) and url.strip():
+            urls.append(url.strip())
+    return urls
+
+
 def get_model_name_from_metadata(metadata: Dict) -> str:
     """Extract the model display name from metadata."""
-    # Try civitai model name first, then file_name, then fallback
     name = metadata.get("model_name", "")
     if not name:
-        civitai = metadata.get("civitai", {})
-        model = civitai.get("model", {})
+        civitai = _get_civitai(metadata)
+        model = civitai.get("model") or {}
         name = model.get("name", "")
     if not name:
         name = metadata.get("file_name", "unknown")
     return name
 
 
-def get_preview_image_from_metadata(
-    metadata: Dict, metadata_path: Path
-) -> Optional[str]:
-    """Find the preview image path for a LoRA from its metadata.
+def get_preview_images_from_metadata(metadata: Dict, metadata_path: Path) -> List[str]:
+    """Find all local preview/example image paths for a LoRA.
 
     Returns:
-        Absolute path string to the preview image, or None.
+        List of absolute path strings to image files.
     """
+    results = []
     lora_dir = metadata_path.parent
     file_name = metadata.get("file_name", "")
     if not file_name:
-        # Derive from metadata filename: "foo.metadata.json" -> "foo"
         stem = metadata_path.name.replace(".metadata.json", "")
         file_name = stem
 
     base_name = Path(file_name).stem
 
     # Check standard preview naming conventions
-    for ext in (".png", ".jpg", ".jpeg", ".preview.png", ".preview.jpg"):
+    for ext in (
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".webp",
+        ".preview.png",
+        ".preview.jpg",
+        ".preview.jpeg",
+    ):
         candidate = lora_dir / f"{base_name}{ext}"
         if candidate.exists():
-            return str(candidate.resolve())
+            results.append(str(candidate.resolve()))
 
-    return None
+    return results
+
+
+def get_preview_image_from_metadata(
+    metadata: Dict, metadata_path: Path
+) -> Optional[str]:
+    """Find the first preview image path for a LoRA (backward compat)."""
+    images = get_preview_images_from_metadata(metadata, metadata_path)
+    return images[0] if images else None
 
 
 def get_example_images_dir(lora_manager_path: str) -> Optional[str]:

From 890fd70ac59cb033918af73a367dcd6edea5958b Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:26:15 -0700
Subject: [PATCH 15/24] feat: reimport clears previous lora-manager data first
 (#52)

Clicking Import LoRA Data now deletes all existing lora-manager
category prompts before scanning, ensuring a clean reimport.
---
 database/operations.py     | 32 ++++++++++++++++++++++++++++++++
 py/api/lora_integration.py | 15 ++++++++++++++-
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/database/operations.py b/database/operations.py
index ad9b6ae..ce48a29 100644
--- a/database/operations.py
+++ b/database/operations.py
@@ -444,6 +444,38 @@ def delete_prompt(self, prompt_id: int) -> bool:
             conn.commit()
             return cursor.rowcount > 0
 
+    def delete_prompts_by_category(self, category: str) -> int:
+        """Delete all prompts with the given category.
+
+        Returns:
+            Number of prompts deleted.
+        """
+        with self.model.get_connection() as conn:
+            # Get IDs first for cascade cleanup
+            ids = [
+                r[0]
+                for r in conn.execute(
+                    "SELECT id FROM prompts WHERE category = ?", (category,)
+                ).fetchall()
+            ]
+            if not ids:
+                return 0
+            placeholders = ",".join("?" * len(ids))
+            conn.execute(
+                f"DELETE FROM generated_images WHERE prompt_id IN ({placeholders})",
+                ids,
+            )
+            conn.execute(
+                f"DELETE FROM prompt_tags WHERE prompt_id IN ({placeholders})",
+                ids,
+            )
+            cursor = conn.execute(
+                f"DELETE FROM prompts WHERE id IN ({placeholders})",
+                ids,
+            )
+            conn.commit()
+            return cursor.rowcount
+
     def get_all_categories(self) -> List[str]:
         """
         Get all unique categories from the database.
diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index f5f910f..c2ca9d6 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -191,11 +191,24 @@ async def send_progress(data):
             await send_progress(
                 {
                     "type": "progress",
-                    "status": "Finding LoRA directories...",
+                    "status": "Clearing previous lora-manager imports...",
                     "progress": 0,
                 }
             )
 
+            # Clear previous imports so reimport is always clean
+            await self._run_in_executor(
+                self.db.delete_prompts_by_category, "lora-manager"
+            )
+
+            await send_progress(
+                {
+                    "type": "progress",
+                    "status": "Finding LoRA directories...",
+                    "progress": 2,
+                }
+            )
+
             lora_dirs = await self._run_in_executor(find_lora_directories, lm_path)
 
             # Collect all metadata files

From 451596fab3fa977e289ddc1b5e656848f4a451c6 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:33:47 -0700
Subject: [PATCH 16/24] feat: download civitai example images during LoRA
 import (#52)

Images from civitai.images[] are downloaded to data/lora_images/ cache
and linked to prompts alongside local preview files. Cached files are
reused on reimport. Image serving allows the cache directory.
---
 .gitignore                 |  1 +
 py/api/images.py           |  6 +++-
 py/api/lora_integration.py | 23 +++++++++++--
 py/lora_utils.py           | 67 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 93 insertions(+), 4 deletions(-)

diff --git a/.gitignore b/.gitignore
index 9248013..59734d7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@ AGENTS.md
 CLAUDE.md
 
 # Local files
+data/
 docs/
 logs/
 standalone_tagger.py
diff --git a/py/api/images.py b/py/api/images.py
index 47c3fca..95877f7 100644
--- a/py/api/images.py
+++ b/py/api/images.py
@@ -311,12 +311,16 @@ async def serve_image(self, request):
                 from ..config import IntegrationConfig
 
                 if IntegrationConfig.LORA_MANAGER_ENABLED:
-                    from ..lora_utils import find_lora_directories
+                    from ..lora_utils import (
+                        find_lora_directories,
+                        get_lora_image_cache_dir,
+                    )
 
                     lora_dirs = find_lora_directories(
                         IntegrationConfig.LORA_MANAGER_PATH
                     )
                     allowed_dirs.extend(Path(d) for d in lora_dirs)
+                    allowed_dirs.append(get_lora_image_cache_dir())
             except Exception:
                 pass
 
diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index c2ca9d6..82171ed 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -153,8 +153,10 @@ async def lora_scan(self, request):
         try:
             from ..config import IntegrationConfig
             from ..lora_utils import (
+                download_civitai_images,
                 find_lora_directories,
                 get_example_prompt_from_metadata,
+                get_lora_image_cache_dir,
                 get_preview_images_from_metadata,
                 get_trigger_words_from_metadata,
                 get_model_name_from_metadata,
@@ -230,6 +232,8 @@ async def send_progress(data):
                 }
             )
 
+            cache_dir = get_lora_image_cache_dir()
+
             for i, meta_file in enumerate(meta_files):
                 metadata = await self._run_in_executor(read_lora_metadata, meta_file)
                 if not metadata:
@@ -238,9 +242,22 @@ async def send_progress(data):
 
                 model_name = get_model_name_from_metadata(metadata)
                 trigger_words = get_trigger_words_from_metadata(metadata)
+
+                # Collect all images: local previews + downloaded civitai examples
                 preview_paths = await self._run_in_executor(
                     get_preview_images_from_metadata, metadata, meta_file
                 )
+                civitai_paths = await self._run_in_executor(
+                    download_civitai_images, metadata, meta_file, cache_dir
+                )
+
+                # Merge, local first, dedup
+                seen = set(preview_paths)
+                all_images = list(preview_paths)
+                for cp in civitai_paths:
+                    if cp not in seen:
+                        all_images.append(cp)
+                        seen.add(cp)
 
                 # Build prompt text: prefer example prompt, then model name
                 example_prompt = get_example_prompt_from_metadata(metadata)
@@ -263,8 +280,8 @@ async def send_progress(data):
                     )
 
                     if existing:
-                        # Link all preview images
-                        for pp in preview_paths:
+                        # Link all images
+                        for pp in all_images:
                             await self._run_in_executor(
                                 self.db.link_image_to_prompt,
                                 existing["id"],
@@ -283,7 +300,7 @@ async def send_progress(data):
                         )
 
                         if prompt_id:
-                            for pp in preview_paths:
+                            for pp in all_images:
                                 await self._run_in_executor(
                                     self.db.link_image_to_prompt,
                                     prompt_id,
diff --git a/py/lora_utils.py b/py/lora_utils.py
index 6bd4e80..dab96f6 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -7,10 +7,12 @@
 return empty results rather than raising.
 """
 
+import hashlib
 import json
 import os
 import re
 import threading
+import urllib.request
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
@@ -294,6 +296,71 @@ def get_preview_image_from_metadata(
     return images[0] if images else None
 
 
+def download_civitai_images(
+    metadata: Dict, metadata_path: Path, cache_dir: Path
+) -> List[str]:
+    """Download civitai example images to a local cache directory.
+
+    Images are stored as ``<cache_dir>/<lora_stem>/<hash>.jpg``.
+    Already-downloaded files are skipped.
+
+    Returns:
+        List of absolute paths to downloaded image files.
+    """
+    civitai = _get_civitai(metadata)
+    images = civitai.get("images", []) or []
+    if not images:
+        return []
+
+    file_name = metadata.get("file_name", "")
+    if not file_name:
+        file_name = metadata_path.name.replace(".metadata.json", "")
+    lora_stem = Path(file_name).stem
+
+    lora_cache = cache_dir / lora_stem
+    lora_cache.mkdir(parents=True, exist_ok=True)
+
+    downloaded = []
+    for img in images:
+        if not isinstance(img, dict):
+            continue
+        url = img.get("url", "")
+        if not isinstance(url, str) or not url.startswith("http"):
+            continue
+
+        # Deterministic filename from URL
+        url_hash = hashlib.md5(url.encode()).hexdigest()[:12]
+        ext = ".jpg"  # civitai images are typically jpeg
+        if ".png" in url.lower():
+            ext = ".png"
+        local_path = lora_cache / f"{url_hash}{ext}"
+
+        if local_path.exists():
+            downloaded.append(str(local_path.resolve()))
+            continue
+
+        try:
+            req = urllib.request.Request(
+                url, headers={"User-Agent": "ComfyUI-PromptManager/1.0"}
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                local_path.write_bytes(resp.read())
+            downloaded.append(str(local_path.resolve()))
+        except Exception as e:
+            logger.debug(f"Failed to download {url}: {e}")
+
+    return downloaded
+
+
+def get_lora_image_cache_dir() -> Path:
+    """Get the directory used to cache downloaded LoRA example images."""
+    # Store in the extension's own directory
+    ext_root = Path(__file__).resolve().parent.parent
+    cache = ext_root / "data" / "lora_images"
+    cache.mkdir(parents=True, exist_ok=True)
+    return cache
+
+
 def get_example_images_dir(lora_manager_path: str) -> Optional[str]:
     """Find the LoraManager example_images directory."""
     lm_path = Path(lora_manager_path)

From 0e41e6d65c2d989781b07567270fdd31c815934a Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:41:41 -0700
Subject: [PATCH 17/24] feat: add CivitAI API key setting for authenticated
 image downloads (#52)

Most civitai example images (especially NSFW) require authentication.
Adds API key field to the Integrations settings panel, passed as
Bearer token when downloading example images.
---
 py/api/lora_integration.py |  9 ++++++++-
 py/config.py               |  4 ++++
 py/lora_utils.py           | 12 ++++++++----
 web/admin.html             |  7 +++++++
 web/js/admin.js            |  3 +++
 5 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index 82171ed..20d7ee4 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -76,6 +76,7 @@ async def lora_status(self, request):
                     "enabled": config["enabled"],
                     "path": config["path"],
                     "trigger_words_enabled": config["trigger_words_enabled"],
+                    "civitai_api_key": config.get("civitai_api_key", ""),
                     "detected": detected_path is not None,
                     "detected_path": detected_path or "",
                     "trigger_cache_loaded": cache.is_loaded,
@@ -94,6 +95,7 @@ async def lora_enable(self, request):
             enabled = data.get("enabled", False)
             path = data.get("path", "")
             trigger_words = data.get("trigger_words_enabled", False)
+            civitai_key = data.get("civitai_api_key", "")
 
             from ..config import IntegrationConfig, PromptManagerConfig
             from ..lora_utils import detect_lora_manager, get_trigger_cache
@@ -115,6 +117,7 @@ async def lora_enable(self, request):
             IntegrationConfig.LORA_MANAGER_ENABLED = enabled
             IntegrationConfig.LORA_MANAGER_PATH = path
             IntegrationConfig.LORA_TRIGGER_WORDS_ENABLED = trigger_words
+            IntegrationConfig.CIVITAI_API_KEY = civitai_key
 
             # Persist to config.json
             config_dir = os.path.dirname(
@@ -248,7 +251,11 @@ async def send_progress(data):
                     get_preview_images_from_metadata, metadata, meta_file
                 )
                 civitai_paths = await self._run_in_executor(
-                    download_civitai_images, metadata, meta_file, cache_dir
+                    download_civitai_images,
+                    metadata,
+                    meta_file,
+                    cache_dir,
+                    IntegrationConfig.CIVITAI_API_KEY,
                 )
 
                 # Merge, local first, dedup
diff --git a/py/config.py b/py/config.py
index 360b2e2..88ef6b9 100644
--- a/py/config.py
+++ b/py/config.py
@@ -212,6 +212,7 @@ class IntegrationConfig:
     LORA_MANAGER_ENABLED = False
     LORA_MANAGER_PATH = ""  # Auto-detected if empty
     LORA_TRIGGER_WORDS_ENABLED = False  # Auto-inject trigger words into prompts
+    CIVITAI_API_KEY = ""  # Required to download NSFW example images
 
     @classmethod
     def get_config(cls) -> Dict[str, Any]:
@@ -220,6 +221,7 @@ def get_config(cls) -> Dict[str, Any]:
                 "enabled": cls.LORA_MANAGER_ENABLED,
                 "path": cls.LORA_MANAGER_PATH,
                 "trigger_words_enabled": cls.LORA_TRIGGER_WORDS_ENABLED,
+                "civitai_api_key": cls.CIVITAI_API_KEY,
             },
         }
 
@@ -232,6 +234,8 @@ def update_config(cls, new_config: Dict[str, Any]):
             cls.LORA_MANAGER_PATH = lora["path"]
         if "trigger_words_enabled" in lora:
             cls.LORA_TRIGGER_WORDS_ENABLED = lora["trigger_words_enabled"]
+        if "civitai_api_key" in lora:
+            cls.CIVITAI_API_KEY = lora["civitai_api_key"]
 
 
 class PromptManagerConfig:
diff --git a/py/lora_utils.py b/py/lora_utils.py
index dab96f6..0eb90d9 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -297,13 +297,16 @@ def get_preview_image_from_metadata(
 
 
 def download_civitai_images(
-    metadata: Dict, metadata_path: Path, cache_dir: Path
+    metadata: Dict, metadata_path: Path, cache_dir: Path, api_key: str = ""
 ) -> List[str]:
     """Download civitai example images to a local cache directory.
 
     Images are stored as ``<cache_dir>/<lora_stem>/<hash>.jpg``.
     Already-downloaded files are skipped.
 
+    Args:
+        api_key: CivitAI API key for authenticated downloads (NSFW content).
+
     Returns:
         List of absolute paths to downloaded image files.
     """
@@ -340,9 +343,10 @@ def download_civitai_images(
             continue
 
         try:
-            req = urllib.request.Request(
-                url, headers={"User-Agent": "ComfyUI-PromptManager/1.0"}
-            )
+            headers = {"User-Agent": "ComfyUI-PromptManager/1.0"}
+            if api_key:
+                headers["Authorization"] = f"Bearer {api_key}"
+            req = urllib.request.Request(url, headers=headers)
             with urllib.request.urlopen(req, timeout=15) as resp:
                 local_path.write_bytes(resp.read())
             downloaded.append(str(local_path.resolve()))
diff --git a/web/admin.html b/web/admin.html
index ea58c47..a810f20 100644
--- a/web/admin.html
+++ b/web/admin.html
@@ -439,6 +439,13 @@ <h4 class="text-xs font-semibold text-pm-secondary mb-3 uppercase tracking-wide"
                             </div>
                             <p class="text-xs text-pm-muted">Automatically append trigger words when <code class="text-pm-accent">&lt;lora:name:weight&gt;</code> is detected in prompts.</p>
 
+                            <div class="mt-2">
+                                <label class="block text-xs font-medium text-pm-secondary mb-1">CivitAI API Key</label>
+                                <input type="password" id="civitaiApiKey" placeholder="Optional — required for NSFW example images"
+                                       class="w-full px-2.5 py-1.5 bg-pm-input border border-pm rounded-pm-sm text-pm text-[13px] placeholder:text-pm-muted focus:outline-none">
+                                <p class="text-xs text-pm-muted mt-1">Get your key from <a href="https://civitai.com/user/account" target="_blank" class="text-pm-accent hover:underline">civitai.com/user/account</a></p>
+                            </div>
+
                             <button id="loraImportBtn" type="button"
                                     class="mt-1 flex items-center gap-1 text-xs text-pm-accent hover:text-pm-accent-hover">
                                 <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
diff --git a/web/js/admin.js b/web/js/admin.js
index 6e4cb9b..10bec94 100644
--- a/web/js/admin.js
+++ b/web/js/admin.js
@@ -796,6 +796,7 @@
                             toggle.disabled = false;
                             document.getElementById("loraManagerPath").value = status.path;
                             document.getElementById("loraTriggerWords").checked = status.trigger_words_enabled;
+                            document.getElementById("civitaiApiKey").value = status.civitai_api_key || "";
                             settings.classList.remove("hidden");
                             this._loraPath = status.path;
                             this._bindLoraEvents();
@@ -850,6 +851,7 @@
             async saveLoraSettings() {
                 const enabled = document.getElementById("loraEnabled").checked;
                 const triggerWords = document.getElementById("loraTriggerWords").checked;
+                const civitaiKey = document.getElementById("civitaiApiKey").value.trim();
                 const path = this._loraPath || "";
 
                 try {
@@ -860,6 +862,7 @@
                             enabled,
                             path,
                             trigger_words_enabled: triggerWords,
+                            civitai_api_key: civitaiKey,
                         }),
                     });
                     const data = await res.json();

From b24343dc6c82ca2d7167203aede8ce1d408d8e7e Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:46:08 -0700
Subject: [PATCH 18/24] feat(ui): add progress modal for LoRA import (#52)

Closes settings modal and shows a dedicated progress modal with
progress bar, status text, and processed/imported counts during
LoRA import. Auto-closes after completion.
---
 web/admin.html  | 26 ++++++++++++++++++++++++++
 web/js/admin.js | 33 +++++++++++++++++++++++++++------
 2 files changed, 53 insertions(+), 6 deletions(-)

diff --git a/web/admin.html b/web/admin.html
index a810f20..ecccce0 100644
--- a/web/admin.html
+++ b/web/admin.html
@@ -471,6 +471,32 @@ <h4 class="text-xs font-semibold text-pm-secondary mb-3 uppercase tracking-wide"
         </div>
     </div>
 
+    <!-- LoRA Import Progress Modal -->
+    <div id="loraImportModal" class="fixed inset-0 bg-black/60 backdrop-blur-[2px] hidden items-center justify-center z-50">
+        <div class="bg-pm-surface rounded-pm-lg p-4 max-w-md w-full mx-4 border border-pm shadow-pm">
+            <h3 class="text-sm font-semibold text-pm mb-4">Importing LoRA Data</h3>
+
+            <div class="mb-3">
+                <p class="text-pm-secondary text-xs">Status:</p>
+                <p id="loraImportStatus" class="text-pm text-xs font-medium truncate">Initializing...</p>
+            </div>
+
+            <div class="mb-3">
+                <div class="flex justify-between text-xs text-pm-secondary mb-1">
+                    <span>Progress</span>
+                    <span id="loraImportPercent">0%</span>
+                </div>
+                <div class="w-full bg-pm-input rounded-full h-1.5">
+                    <div id="loraImportBar" class="bg-pm-accent h-1.5 rounded-full transition-all duration-300" style="width: 0%"></div>
+                </div>
+                <div class="flex justify-between text-[11px] text-pm-muted mt-1">
+                    <span id="loraImportProcessed">0 processed</span>
+                    <span id="loraImportImported">0 imported</span>
+                </div>
+            </div>
+        </div>
+    </div>
+
     <!-- Bulk Tag Modal -->
     <div id="bulkTagModal" class="fixed inset-0 bg-black/60 backdrop-blur-[2px] hidden items-center justify-center z-50">
         <div class="bg-pm-surface rounded-pm-lg p-4 max-w-md w-full mx-4 border border-pm shadow-pm">
diff --git a/web/js/admin.js b/web/js/admin.js
index 10bec94..5910bb7 100644
--- a/web/js/admin.js
+++ b/web/js/admin.js
@@ -881,7 +881,14 @@
                 const saved = await this.saveLoraSettings();
                 if (!saved) return;
 
-                this.showNotification("Scanning LoRA metadata...", "info");
+                // Close settings and show progress modal
+                this.hideModal("settingsModal");
+                document.getElementById("loraImportStatus").textContent = "Initializing...";
+                document.getElementById("loraImportBar").style.width = "0%";
+                document.getElementById("loraImportPercent").textContent = "0%";
+                document.getElementById("loraImportProcessed").textContent = "0 processed";
+                document.getElementById("loraImportImported").textContent = "0 imported";
+                this.showModal("loraImportModal");
 
                 try {
                     const res = await fetch("/prompt_manager/lora/scan", { method: "POST" });
@@ -901,18 +908,32 @@
                             if (!line.startsWith("data: ")) continue;
                             try {
                                 const data = JSON.parse(line.slice(6));
+                                const pct = data.progress || 0;
+                                document.getElementById("loraImportBar").style.width = `${pct}%`;
+                                document.getElementById("loraImportPercent").textContent = `${pct}%`;
+
+                                if (data.status) {
+                                    document.getElementById("loraImportStatus").textContent = data.status;
+                                }
+                                if (data.processed !== undefined) {
+                                    document.getElementById("loraImportProcessed").textContent = `${data.processed} processed`;
+                                }
+                                if (data.imported !== undefined) {
+                                    document.getElementById("loraImportImported").textContent = `${data.imported} imported`;
+                                }
+
                                 if (data.type === "complete") {
-                                    this.showNotification(
-                                        `LoRA import complete: ${data.imported} imported, ${data.skipped} skipped`,
-                                        data.imported > 0 ? "success" : "info"
-                                    );
+                                    document.getElementById("loraImportStatus").textContent =
+                                        `Done — ${data.imported} imported, ${data.skipped} skipped`;
                                     this.loadStatistics();
+                                    setTimeout(() => this.hideModal("loraImportModal"), 2000);
                                 }
                             } catch (e) { /* skip malformed SSE */ }
                         }
                     }
                 } catch (e) {
-                    this.showNotification("LoRA import failed: " + e.message, "error");
+                    document.getElementById("loraImportStatus").textContent = `Error: ${e.message}`;
+                    setTimeout(() => this.hideModal("loraImportModal"), 3000);
                 }
             }
 

From 195cf2adb4f1760e41d208f0c4785eb2ad2f14ec Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 08:56:09 -0700
Subject: [PATCH 19/24] fix: reduce download timeout to 5s, update progress per
 LoRA (#52)

5K images at 15s timeout was painfully slow. Reduced to 5s fail-fast.
Progress now updates for every LoRA with image count, not every 5th.
---
 py/api/lora_integration.py | 29 ++++++++++++++++-------------
 py/lora_utils.py           |  2 +-
 2 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/py/api/lora_integration.py b/py/api/lora_integration.py
index 20d7ee4..6275bfd 100644
--- a/py/api/lora_integration.py
+++ b/py/api/lora_integration.py
@@ -321,19 +321,22 @@ async def send_progress(data):
                     self.logger.warning(f"Failed to import LoRA {model_name}: {e}")
                     skipped += 1
 
-                # Progress update every 5 items or at the end
-                if (i + 1) % 5 == 0 or i == total - 1:
-                    progress = int(5 + (90 * (i + 1) / max(total, 1)))
-                    await send_progress(
-                        {
-                            "type": "progress",
-                            "status": f"Processing: {model_name}",
-                            "progress": progress,
-                            "processed": i + 1,
-                            "imported": imported,
-                            "skipped": skipped,
-                        }
-                    )
+                # Progress update for every LoRA
+                progress = int(5 + (90 * (i + 1) / max(total, 1)))
+                img_count = len(all_images)
+                status = f"{model_name}"
+                if img_count:
+                    status += f" ({img_count} images)"
+                await send_progress(
+                    {
+                        "type": "progress",
+                        "status": status,
+                        "progress": progress,
+                        "processed": i + 1,
+                        "imported": imported,
+                        "skipped": skipped,
+                    }
+                )
 
             await send_progress(
                 {
diff --git a/py/lora_utils.py b/py/lora_utils.py
index 0eb90d9..8c262be 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -347,7 +347,7 @@ def download_civitai_images(
             if api_key:
                 headers["Authorization"] = f"Bearer {api_key}"
             req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=15) as resp:
+            with urllib.request.urlopen(req, timeout=5) as resp:
                 local_path.write_bytes(resp.read())
             downloaded.append(str(local_path.resolve()))
         except Exception as e:

From 50f04a62239386272914d22ee856bfab5ec34992 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 10:02:05 -0700
Subject: [PATCH 20/24] perf: use 512px thumbnails and parallel downloads for
 LoRA images (#52)

Full-size civitai images averaged 5.6MB each (27GB total for 5K images).
Now requests /width=512/ thumbnails (~50-100KB) and downloads 8 in
parallel per LoRA. Expected speedup: ~100x smaller + 8x parallel.
---
 py/lora_utils.py | 77 ++++++++++++++++++++++++++++++++++--------------
 1 file changed, 55 insertions(+), 22 deletions(-)

diff --git a/py/lora_utils.py b/py/lora_utils.py
index 8c262be..432b1c0 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -296,13 +296,41 @@ def get_preview_image_from_metadata(
     return images[0] if images else None
 
 
+def _to_thumbnail_url(url: str, width: int = 512) -> str:
+    """Convert a civitai image URL to a thumbnail URL.
+
+    Replaces /original=true/ or /width=N/ with /width=512/ for much
+    smaller downloads (~50KB vs ~5MB).
+    """
+    import re as _re
+
+    url = _re.sub(r"/original=true/", f"/width={width}/", url)
+    url = _re.sub(r"/width=\d+/", f"/width={width}/", url)
+    return url
+
+
+def _download_one(url: str, local_path: Path, api_key: str) -> Optional[str]:
+    """Download a single image. Returns the local path on success, None on failure."""
+    try:
+        headers = {"User-Agent": "ComfyUI-PromptManager/1.0"}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        req = urllib.request.Request(url, headers=headers)
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            local_path.write_bytes(resp.read())
+        return str(local_path.resolve())
+    except Exception as e:
+        logger.debug(f"Failed to download {url}: {e}")
+        return None
+
+
 def download_civitai_images(
     metadata: Dict, metadata_path: Path, cache_dir: Path, api_key: str = ""
 ) -> List[str]:
     """Download civitai example images to a local cache directory.
 
-    Images are stored as ``<cache_dir>/<lora_stem>/<hash>.jpg``.
-    Already-downloaded files are skipped.
+    Uses thumbnail URLs (512px) instead of full-size originals, and
+    downloads in parallel (up to 8 concurrent) for speed.
 
     Args:
         api_key: CivitAI API key for authenticated downloads (NSFW content).
@@ -310,6 +338,8 @@ def download_civitai_images(
     Returns:
         List of absolute paths to downloaded image files.
     """
+    from concurrent.futures import ThreadPoolExecutor
+
     civitai = _get_civitai(metadata)
     images = civitai.get("images", []) or []
     if not images:
@@ -323,7 +353,9 @@ def download_civitai_images(
     lora_cache = cache_dir / lora_stem
     lora_cache.mkdir(parents=True, exist_ok=True)
 
-    downloaded = []
+    # Build download tasks
+    cached = []
+    tasks = []  # (url, local_path)
     for img in images:
         if not isinstance(img, dict):
             continue
@@ -331,29 +363,30 @@ def download_civitai_images(
         if not isinstance(url, str) or not url.startswith("http"):
             continue
 
-        # Deterministic filename from URL
-        url_hash = hashlib.md5(url.encode()).hexdigest()[:12]
-        ext = ".jpg"  # civitai images are typically jpeg
-        if ".png" in url.lower():
-            ext = ".png"
-        local_path = lora_cache / f"{url_hash}{ext}"
+        thumb_url = _to_thumbnail_url(url)
+        url_hash = hashlib.md5(thumb_url.encode()).hexdigest()[:12]
+        local_path = lora_cache / f"{url_hash}.jpg"
 
         if local_path.exists():
-            downloaded.append(str(local_path.resolve()))
-            continue
+            cached.append(str(local_path.resolve()))
+        else:
+            tasks.append((thumb_url, local_path))
 
-        try:
-            headers = {"User-Agent": "ComfyUI-PromptManager/1.0"}
-            if api_key:
-                headers["Authorization"] = f"Bearer {api_key}"
-            req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=5) as resp:
-                local_path.write_bytes(resp.read())
-            downloaded.append(str(local_path.resolve()))
-        except Exception as e:
-            logger.debug(f"Failed to download {url}: {e}")
+    if not tasks:
+        return cached
 
-    return downloaded
+    # Download in parallel
+    downloaded = []
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        futures = [
+            pool.submit(_download_one, url, path, api_key) for url, path in tasks
+        ]
+        for fut in futures:
+            result = fut.result()
+            if result:
+                downloaded.append(result)
+
+    return cached + downloaded
 
 
 def get_lora_image_cache_dir() -> Path:

From 3ee4a8b6a522462d7dca326bdc499ede57682213 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 10:18:35 -0700
Subject: [PATCH 21/24] fix: resize downloaded images to 512px thumbnails
 locally (#52)

Civitai CDN returns 401 for /width=N/ thumbnail URLs with API key auth.
Instead, download the original and resize to 512px via PIL before saving.
Reduces disk usage from ~5MB to ~30-50KB per image.
---
 py/lora_utils.py | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/py/lora_utils.py b/py/lora_utils.py
index 432b1c0..d70620c 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -296,28 +296,29 @@ def get_preview_image_from_metadata(
     return images[0] if images else None
 
 
-def _to_thumbnail_url(url: str, width: int = 512) -> str:
-    """Convert a civitai image URL to a thumbnail URL.
-
-    Replaces /original=true/ or /width=N/ with /width=512/ for much
-    smaller downloads (~50KB vs ~5MB).
-    """
-    import re as _re
-
-    url = _re.sub(r"/original=true/", f"/width={width}/", url)
-    url = _re.sub(r"/width=\d+/", f"/width={width}/", url)
-    return url
+_THUMB_MAX_SIZE = 512
 
 
 def _download_one(url: str, local_path: Path, api_key: str) -> Optional[str]:
-    """Download a single image. Returns the local path on success, None on failure."""
+    """Download a single image, resize to thumbnail, save as JPEG."""
     try:
         headers = {"User-Agent": "ComfyUI-PromptManager/1.0"}
         if api_key:
             headers["Authorization"] = f"Bearer {api_key}"
         req = urllib.request.Request(url, headers=headers)
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            local_path.write_bytes(resp.read())
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            raw = resp.read()
+
+        # Resize to thumbnail to save disk space
+        from io import BytesIO
+
+        from PIL import Image
+
+        img = Image.open(BytesIO(raw))
+        img.thumbnail((_THUMB_MAX_SIZE, _THUMB_MAX_SIZE), Image.LANCZOS)
+        img = img.convert("RGB")
+        img.save(str(local_path), "JPEG", quality=85)
+
         return str(local_path.resolve())
     except Exception as e:
         logger.debug(f"Failed to download {url}: {e}")
@@ -363,14 +364,13 @@ def download_civitai_images(
         if not isinstance(url, str) or not url.startswith("http"):
             continue
 
-        thumb_url = _to_thumbnail_url(url)
-        url_hash = hashlib.md5(thumb_url.encode()).hexdigest()[:12]
+        url_hash = hashlib.md5(url.encode()).hexdigest()[:12]
         local_path = lora_cache / f"{url_hash}.jpg"
 
         if local_path.exists():
             cached.append(str(local_path.resolve()))
         else:
-            tasks.append((thumb_url, local_path))
+            tasks.append((url, local_path))
 
     if not tasks:
         return cached

From 1157714b80aa1ed80e70d68987bea426a13f8b32 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 18:13:51 -0700
Subject: [PATCH 22/24] docs: update README for v3.2.1 LoRA Manager integration
 (#52)

- Add LoRA Manager integration section with setup guide and CivitAI key docs
- Add folder filter section with rescan note for existing libraries
- Add v3.2.1 changelog entry, split from v3.2.0
- Add WIP notice for LoRA Manager feature
- Update AutoTag section to include WD14 models
- Fix stale references (KikoTextEncode, outdated file structure)
- Remove dated v2 development note
- Add screenshots for settings, integration, and filtered results
- Fix code review items: remove unused constant, add comments to empty excepts
- Bump version to 3.2.1
---
 README.md                           | 129 +++++++++++++++++++++-------
 images/pm-lora-enabled.png          | Bin 0 -> 50945 bytes
 images/pm-lora-filtered.png         | Bin 0 -> 38620 bytes
 images/pm-lora-import.png           | Bin 0 -> 38408 bytes
 images/pm-lora-results.png          | Bin 0 -> 34717 bytes
 images/pm-settings-integrations.png | Bin 0 -> 45680 bytes
 py/api/images.py                    |   1 +
 py/lora_utils.py                    |   4 +-
 pyproject.toml                      |   2 +-
 9 files changed, 102 insertions(+), 34 deletions(-)
 create mode 100644 images/pm-lora-enabled.png
 create mode 100644 images/pm-lora-filtered.png
 create mode 100644 images/pm-lora-import.png
 create mode 100644 images/pm-lora-results.png
 create mode 100644 images/pm-settings-integrations.png

diff --git a/README.md b/README.md
index d68effd..5f960f9 100644
--- a/README.md
+++ b/README.md
@@ -6,13 +6,7 @@
 ![Tests](https://github.com/ComfyAssets/ComfyUI_PromptManager/workflows/Tests/badge.svg)
 ![Code Quality](https://github.com/ComfyAssets/ComfyUI_PromptManager/workflows/Code%20Quality/badge.svg)
 
-A comprehensive ComfyUI custom node that extends the standard text encoder with persistent prompt storage, advanced search capabilities, automatic image gallery system, and powerful ComfyUI workflow metadata analysis using SQLite.
-
-## 📋 A Note on v2 Development
-
-V2 development will take longer as life has taken me in other directions for the moment. I will still work on it but not as actively as before. In the meantime, I will backport some of the features users have requested from v2 over to v1. Once v2 is ready, I will update here. Thank you for your continued support!
-
----
+A comprehensive ComfyUI custom node that extends the standard text encoder with persistent prompt storage, advanced search capabilities, automatic image gallery system, folder-based organization, LoRA Manager integration, and powerful ComfyUI workflow metadata analysis using SQLite.
 
 ## Overview
 
@@ -54,6 +48,7 @@ Both nodes include the complete PromptManager feature set:
 
 - **💾 Persistent Storage**: Automatically saves all prompts to a local SQLite database
 - **🔍 Advanced Search**: Query past prompts with text search, category filtering, and metadata
+- **📁 Folder Filter**: Browse and filter prompts by output subdirectory
 - **🖼️ Automatic Image Gallery**: Automatically links generated images to their prompts
 - **🏷️ Rich Metadata**: Add categories, tags, ratings, notes, and workflow names to prompts
 - **🚫 Duplicate Prevention**: Uses SHA256 hashing to detect and prevent duplicate storage
@@ -62,7 +57,8 @@ Both nodes include the complete PromptManager feature set:
 - **🔬 Workflow Analysis**: Extract and analyze ComfyUI workflow data from PNG images
 - **📋 Metadata Viewer**: Standalone tool for analyzing ComfyUI-generated images
 - **🛠️ System Management**: Built-in diagnostics, backup/restore, and maintenance tools
-- **🏷️ AI AutoTag**: Automatically tag your image collection using JoyCaption vision models
+- **🏷️ AI AutoTag**: Automatically tag your image collection using WD14 or JoyCaption vision models
+- **🔗 LoRA Manager Integration**: Import LoRA metadata and preview images from [ComfyUI-Lora-Manager](https://github.com/willchil/ComfyUI-Lora-Manager)
 
 ![Image Gallery](images/pm-02.png)
 
@@ -372,10 +368,11 @@ Import existing ComfyUI images into your database:
 
 ### 🏷️ AI AutoTag
 
-Automatically tag your entire image collection using JoyCaption vision models:
+Automatically tag your entire image collection using AI vision models:
 
 #### **Model Options**
 
+- **WD14 SwinV2 / WD14 ViT**: Fast ONNX-based classifiers (~400MB) that output Danbooru tags with confidence scores — no prompt needed, adjustable confidence thresholds
 - **JoyCaption Beta One FP16**: Full precision model for highest quality tagging (requires more VRAM)
 - **JoyCaption Beta One GGUF (FP8)**: Quantized model for lower VRAM usage with minimal quality loss
 
@@ -417,6 +414,61 @@ Adjust the system prompt to match your tagging style:
 - Models are downloaded automatically on first use
 - Feature requests and improvements are welcome!
 
+### 📁 Folder Filter
+
+![Folder Filter](images/pm-lora-import.png)
+
+Organize and filter your prompt library by output subdirectory. The dashboard search panel includes a **Folder** dropdown that lists all subdirectories where your images are stored.
+
+- **Automatic Detection**: Folders are extracted from your image paths — no configuration needed
+- **Multi-Directory Support**: Works across all configured gallery scan directories
+- **Quick Filtering**: Select a folder from the dropdown to instantly filter prompts to that subdirectory
+
+> **Note:** If you have an existing prompt library from before the folder feature was added, you will need to **rescan your image library** (click **Scan Images** in the admin dashboard) to populate folder data for your existing prompts.
+
+### 🔗 LoRA Manager Integration
+
+![LoRA Settings](images/pm-settings-integrations.png)
+
+If you use [ComfyUI-Lora-Manager](https://github.com/willchil/ComfyUI-Lora-Manager), PromptManager can import your LoRA metadata, trigger words, and example images directly into your prompt database. This lets you search, tag, and browse your LoRA collection alongside your regular prompts.
+
+> **WIP:** LoRA Manager support is a work in progress — this was a highly requested feature. Please [open issues](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues) for any bugs or feature requests.
+
+#### **Enabling the Integration**
+
+1. Open the admin dashboard and click **Settings**
+2. Scroll to the **Integrations** section — PromptManager will auto-detect if LoRA Manager is installed
+
+![LoRA Enabled](images/pm-lora-enabled.png)
+
+3. Toggle the **LoraManager** switch to enable
+4. Optionally enable **Auto-inject trigger words** to automatically append LoRA trigger words when `<lora:name:weight>` is detected in your prompts
+5. Click **Save Settings** (requires a ComfyUI restart to take effect)
+
+#### **Importing LoRA Data**
+
+Click **Import LoRA Data** in the settings panel to start the import. A progress popup shows real-time status as each LoRA is processed:
+
+- Scans all LoRA directories (including `extra_model_paths.yaml` paths) for metadata
+- Downloads example images from CivitAI as 512px thumbnails
+- Creates a prompt entry for each LoRA with trigger words, example prompts, and preview images
+- All imported LoRAs are tagged with `lora-manager` category for easy filtering
+
+![LoRA Results](images/pm-lora-filtered.png)
+
+After import, filter by the `lora-manager` category to browse your LoRA collection.
+
+#### **CivitAI API Key (Optional)**
+
+A CivitAI API key is **required if your library contains NSFW LoRAs** — CivitAI blocks unauthenticated access to NSFW preview images. Without a key, only SFW preview images are downloaded.
+
+To add your key:
+1. Get your API key from [civitai.com/user/account](https://civitai.com/user/account)
+2. Paste it into the **CivitAI API Key** field in the Integrations settings
+3. Save and re-import to download any previously skipped images
+
+> **Note:** Re-importing is safe — PromptManager skips LoRAs that were already imported. To do a fresh import, the previous `lora-manager` data is cleared automatically before re-scanning.
+
 ### 🌐 Web Interface Features
 
 The comprehensive web interface provides:
@@ -600,8 +652,9 @@ CREATE TABLE generated_images (
 - **`prompt_search_list.py`** - Batch search node implementation (LIST output)
 - **`database/models.py`** - Database schema and connection management
 - **`database/operations.py`** - CRUD operations and search functionality
-- **`py/api.py`** - Web API endpoints for the interface
+- **`py/api/`** - Web API route modules (prompts, images, tags, lora integration, etc.)
 - **`py/config.py`** - Configuration management
+- **`py/lora_utils.py`** - LoRA Manager integration utilities
 - **`utils/hashing.py`** - SHA256 hashing for deduplication
 - **`utils/validators.py`** - Input validation and sanitization
 - **`utils/image_monitor.py`** - Automatic image detection system
@@ -611,7 +664,8 @@ CREATE TABLE generated_images (
 - **`utils/diagnostics.py`** - System diagnostics and health checks
 - **`web/admin.html`** - Advanced admin dashboard with metadata panel
 - **`web/index.html`** - Simple web interface
-- **`web/prompt_manager.js`** - JavaScript functionality
+- **`web/js/prompt_manager.js`** - Dashboard JavaScript
+- **`web/js/tags-page.js`** - Tag management JavaScript
 - **`web/metadata.html`** - Standalone PNG metadata viewer
 
 ### File Structure
@@ -628,8 +682,9 @@ ComfyUI_PromptManager/
 │   └── operations.py             # Database operations
 ├── py/
 │   ├── __init__.py
-│   ├── api.py                    # Web API endpoints
-│   └── config.py                 # Configuration
+│   ├── api/                      # Web API route modules
+│   ├── config.py                 # Configuration
+│   └── lora_utils.py             # LoRA Manager integration
 ├── utils/
 │   ├── __init__.py
 │   ├── hashing.py               # Hashing utilities
@@ -641,9 +696,12 @@ ComfyUI_PromptManager/
 │   └── diagnostics.py           # System diagnostics
 ├── web/
 │   ├── admin.html               # Advanced admin dashboard
+│   ├── gallery.html             # Image gallery
 │   ├── index.html               # Simple web interface
 │   ├── metadata.html            # Standalone metadata viewer
-│   └── prompt_manager.js        # JavaScript functionality
+│   └── js/
+│       ├── prompt_manager.js    # Dashboard JavaScript
+│       └── tags-page.js         # Tag management JavaScript
 ├── tests/
 │   ├── __init__.py
 │   └── test_basic.py            # Test suite
@@ -752,7 +810,7 @@ db.model.backup_database("backup_prompts.db")
 ### Running Tests
 
 ```bash
-cd KikoTextEncode
+cd ComfyUI_PromptManager
 python -m pytest tests/ -v
 ```
 
@@ -797,7 +855,7 @@ The project follows PEP 8 guidelines with:
 For debugging, you can enable verbose logging in the node:
 
 ```python
-# Add to kiko_text_encode.py
+# Add to prompt_manager.py
 import logging
 logging.basicConfig(level=logging.DEBUG)
 ```
@@ -814,15 +872,15 @@ MIT License - see LICENSE file for details.
 
 ## Roadmap
 
-### Completed in v3.0.0
+### Recently Completed
 
-- **✅ PNG Metadata Analysis**: Complete ComfyUI workflow extraction from images
-- **✅ Standalone Metadata Viewer**: Dedicated tool for analyzing any ComfyUI image
-- **✅ Advanced Admin Dashboard**: Comprehensive management interface with modern UI
-- **✅ Integrated Metadata Panel**: Real-time workflow analysis in image viewer
-- **✅ Bulk Image Scanning**: Mass import of existing ComfyUI images
-- **✅ System Management Tools**: Backup, restore, diagnostics, and maintenance
-- **✅ Enhanced Error Handling**: Robust PNG parsing with NaN value cleaning
+- **✅ LoRA Manager Integration**: Import LoRA metadata, trigger words, and preview images
+- **✅ Folder Filter**: Browse and filter prompts by output subdirectory
+- **✅ Multi-Directory Gallery**: Scan multiple output directories simultaneously
+- **✅ WD14 Tagger**: Fast ONNX-based auto-tagging with Danbooru tags
+- **✅ Tailwind v4 Migration**: ComfyUI theme token system for consistent styling
+- **✅ Tag Management Page**: Dedicated page for tag search, rename, merge, and delete
+- **✅ Junction Table Tags**: Normalized tag storage with proper foreign keys
 
 ### Planned Features
 
@@ -830,18 +888,27 @@ MIT License - see LICENSE file for details.
 - **🤝 Collaboration**: Share prompt collections with other users
 - **🧠 AI Suggestions**: Recommend similar prompts based on metadata analysis
 - **📈 Advanced Analytics**: Detailed usage statistics and trends with workflow insights
-- **🔌 Plugin System**: Support for third-party extensions and custom analyzers
-- **🎨 Enhanced Batch Processing**: Advanced bulk operations with metadata editing
 - **🔄 Workflow Templates**: Save and reuse common workflow patterns
 - **📊 Visual Analytics**: Charts and graphs for prompt effectiveness analysis
 
-### Integration Ideas
+## Changelog
 
-- **Workflow linking**: Connect prompts to specific workflow templates
-- **Image analysis**: Analyze generated images to improve suggestions
-- **Version control**: Track prompt iterations and effectiveness
+### v3.2.1 (LoRA Manager Integration)
 
-## Changelog
+- **🔗 LoRA Manager Integration**: Import LoRA metadata, trigger words, and CivitAI example images from [ComfyUI-Lora-Manager](https://github.com/willchil/ComfyUI-Lora-Manager) into your prompt database
+- **💉 Auto-Inject Trigger Words**: Optionally append LoRA trigger words when `<lora:name:weight>` is detected in prompts during encoding
+- **🔑 CivitAI API Key Support**: Authenticate with CivitAI to download NSFW preview images
+- **📥 Import Progress Modal**: Real-time SSE streaming progress during LoRA import with per-model status
+
+> **Note:** LoRA Manager support is a WIP — this was a highly requested feature. Please [open issues](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues) for any bugs or feature requests.
+
+### v3.2.0 (Folder Filter & QoL Improvements)
+
+- **📁 Folder Filter**: New folder dropdown in the search panel to filter prompts by output subdirectory
+- **📂 Multi-Directory Gallery Scan**: Configure multiple output directories and browse them all in one gallery
+- **🖼️ Filmstrip Prompt Display**: Show prompt text and copy button in the filmstrip image viewer
+- **🖱️ Click-to-Close Viewer**: Click outside the image viewer to close it
+- **🐛 Bug Fixes**: Fixed database path config, UnboundLocalError in text inputs, node caching skip, diagnostics singleton lifecycle
 
 ### v3.1.0 (WD14 Tagger, Tailwind v4 & Major Refactors)
 
diff --git a/images/pm-lora-enabled.png b/images/pm-lora-enabled.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4a2f65481c5fefd916143159e2f6cf64610c316
GIT binary patch
literal 50945
zcmZs@1z1&E*EYOGKm?_vlt!A3goKiUba$6Xry`wFA|TQrARygc(j`iYbcqOpGzdu7
zKeo^FzW?`K*SD|h91e@M_F8MsImWohec$thswhd{#J+=#Kp<|)%1Edo5Lams2(&9$
zXmCU%UV#jLTzR1;Eq-OH2k8gDpj(P5iXjjckvL~hFyMEZr!s1a2!tmi0`W2kfjEIf
zFINx<7fu9X%>;oEc!xlcK6~GwDg=MH{!B*q1p<L{3-!+xMDlyow_kIXRg}E8hK_y(
zgYfN=!YX_vLRLad!+m<A+1i<W!sF7<l2ZpO;AhKAHksr&8P&}E;23uOTJt`or(axB
z7!}WzQ>vePCRfWQ@6)e_J3qAd6P{|!7PgK}<8k=K?5Zy4Wu{*tSrV5YOvs|PpcL>E
zEebu9^4)Rk$MJ#vegyg<#@ryzb&CG)N%drZe2;z7P7T^EstDlG5QuWm*DI)zKp?P?
z|BoLCf7B2l{`;d`F?u{xRSf@I73$a|A#+%zECvY?G3vKkX4czPte*0ECAI;d|9#`s
zi33SI4_ln>FsmHf37Q-Z>NI^WiSD8z;$EaR!y4;QYm_eP;3VsC7^!Ac=CFhAWB;7}
zBC;qg)L|NZ&eO2E;`~h0H5(7D@m)$}e6_eYKI%{U+SXjxC5`vw!i#GHb6iSHjIY2^
z6Ma_p$^e~=YP~h=VbqKx^o0$&O#|3Qb&7tPh#CGnNARJ}bgz!>lF5$PqkOgi(;7HU
zB~H+uheTbwpbu$16}suYM*K1p-l06(xSQ;8UDTc5Oyn_|&gB{h#8f!1S>b}BqsBW~
zYYES)63k3x``Es{%)8P6H*71sMEf$?&@)D?8%}}rUi+pA=YFW>9N>&k?J_Tmy2{si
zh`$CW{voF-4lLCxJR(R;T*in9=AeQT&uW#~Txzl_*XVvH(lKJek=BFuHM-1K*Dm7V
z(O=G8nz%4T1>Kv$^lN`NV39IlQ8mSV|9**9QIDCp+Z99`2_0c5I@*=ix$VPK9}#1E
zLRlXCw$(}QfPRar95NpwNmU}rII>y0wZiJ^QH!dsUprPjh0NIJ@4h{Smko|G*G(`N
z!+#@{MK3Fo?&$4JF_f)nPR$x7F3KoC$6>=<8rvr4;}<WaoH?%BT(*Q!GO=~V(1ny=
zH86&LY+~XX+LgkhKa}vKo3ynOs{P&FE32!aUw(bl!Pn_a`re%wC*xF7D5a6HB2i>i
zCik49g)%;SgsShJ9Wk#~W^TX5Ua4VYZeHF^%*U*oWH&I2#%wBd=&wJ2f<WjvnpWs=
z!m+?mo><q*%*@R7i8ARdRVySG^89H*eWoydw27X^4R+S@$;N4mB$?sT{CuyQ4d?l(
z)v|6M&RfFnu!XwScpYx7uC5Y|#n51RczE2sdw0l+ha`M{2IhMG4ZW;XRz+rJ$NGNm
zgGZlCD>^zlY$r<FzXY@mYil>f$<n_u(`9tLiM1<e8;@UBF-dH*t?P1WcWwGkW7eV|
zQ<%oCcFx*~X3|!4cCcZi>%hRk?FgxuWViU(*pZo;aE|K;gxv!{*Nt~cNwTwFDyQsb
zXJ@<N+tt?bT#5E8staE`m}&QyxpbRh+se5V>CMKjywY_m&zh{+87Qo#<cQbcR?;@<
z`t{uCX^Ej$V~?5Kxx9JZ%&dbOC)uY&bOeI$eSd#HJoWMM@hIMP%s_`a@;kP+*OAsG
z;ZmF|ofODi$I1I*w@&gyyADRB{<<@K+ESTFmKzo8XZkf`Mw-h#Sgog$!j;=FI_B9M
z>utvv%fiOSMueT?d#`HhJ#!EqL|E$ekWP|t1{Z&ZJ||b#+KF|^%~vJC)gm?Z?vh>l
zrf0EYev6&1vJ^;r#st=*d^J4{Lk3-vl;$o$P4Ay-UYg|MT3T9268+)#VzMz&ZjfEf
zM$8&HtSh6L!*<+-*x34h?R+?-DJMz4-fh{kH%?HN<Id8luV|+%67)s-hKF!=&Br66
zqfsVu#-7TFhSzMWCOwfgQ+D#iIuI|lJTRg6@81t?3kZ#OMU#(b`fBFi+q)3K!1yLc
zl&#SFSOV|%-uvqN7lZ{#5|-M*ST3;(6Fe2E-*5gnJ@*y*h(J6VM!v9>)ug{NrDsb}
zs`8YfqQ*JUQ@--Gb8vK_6`CK7{Niw?;^zq^!%?F_8$~LGw_`S4>X6&;bzag)blcwf
zp(Yn2S7RkxNPj1M@Z&;NuEv@i|1J5`gz>Ur_D|&^2gJ0W%(!VqAih_Zf?u1mhWB@T
zlH>62Qg$Gcj5b$c7}k+Bi!B{i!$9}Iky{E`?M2$FBkK%ZinU5tNnW-EEW?W;boMBa
zni(%<UmFqn$9vO?$J<Jh+;6KUcqGDW6kiy>(m|+eWt%*M3#Ybyf;HBMD`Jw!oS#>u
z8pD)lyC3DSRqrsbVzgJlYO<QpG+eURV!t?Ke6eIq_0TEk{OIq9^4)k;PMUm!7S2LG
z8?)YUeYNLtPy?M*QCo~M;i!)`@yF4U?ehHP>a{+hGNy+QANn1-`MIr)vUoGVbuUW@
z=*);kVo8sTHB6$>$HZ#NVv8tdAICJBvasfv7Zu%1G@qK9Vt#TBDz2({d9Zj;=;&Cc
z{58hpmBjCF<qSVr-KtNpm$2W*&ls~gFKRtuD;g6J5;_YvK3fPTHEMIaih8;`=67VU
zamOn)`!a3pWVJt9N#3i(G~eP^sq;DeMV<a06%kE`KfFYb+VPYW6`L<k){i`4NGvdw
zh-H_>vsg%;>%`Nk6){T>m;4UsTMFwkeevRj=;iUCvDYTA$UG!7C?X0b{)%L-arD+t
zo?JPHC?I2OBhlHot=yTrSr-rxaCUZ<mPRGseQ|zD?YWXM=zCDL0w`ee{nd5>rV4xs
z4gRXO;S$AQjvmHn-ArcRtrzJKS9gOX=%O9{PG>aiAh}Nlja*ISBFR2}SF~2QzZ$V`
z6#h(B6YoRwct}rA&tdE3`HDB3wRlxxmy0gcL1vFDF`iL{{d=XNcu)h|7y?}fz9bus
zoi&szpcwh!qk~0SHEk8f4*t(mcmoqfroOD#ou3chREwaAd$1ij(>B53;@*$t^YKJ=
z1}<K;+&>PIB(YqAnPAr2Ufp1`cCgxE`xIrbmHR}tZyLdTAI>jgCK&d>pPwN8;qXvL
zzWI_jqSm1+<OZssA=W4eG@OiMPM+Lnx@E6BYf$U##q+e{UAswJ6)eJ(E3z@B6=Ww@
z;=fPy)C}_`#klK*{*a?j({ORTHD)89Bji9RYB$9zL*lZnMTZ^O{-MVV8#B=T`xS&q
zCs&d}h6>g>!oNmoO^%I5jp$xDYb1RHlPI60ViieaiNhnP43Jhb9|%H<#bjk=wXm@G
zhDWaE@x+U<o{98PCbP|0q^o~wjw}AGdQJr)@f)3ZU*%FF_2(1$?X_WhlnXmYfB!oB
z_?)k-SkV*u^WH=t$O&)rBq<OR6H`TAv#wdcb#rENl*T$XpRMJk&sx%@9zpIjQ)pX^
zxh}(Wwb4XOX3&O#tQPk0`5Vo{ZnjoUZ$=ACOB@`W``q00vK@5*wz?bgIxz#=lai9+
zi`W+HneMEp%l`avQH7=H8M{ry$bA&iz%9w|BCGwhfPz~$K~gol54Rk%CS5V6%-=yx
zJ5%|sroN$uNx^|Zm)WJeP)j-L^V0Dys@yVFeQI10pj<azGnm%cy&uiE)YpE0Alh>W
z!(Ls(kSjv64k>HGF!7?V`&nKcV;}ckg_av1Doo1_$B2n_V(7V&BtP;}5KBU}u0)Rf
z)Vy;YS#tH0ubIy$Tji3rVcrnuPQOs4Pk+ngcCz20Cs@(;ED|V;MU3DX#h<1#yQ3BW
zB0i8omM~t|ZY9qAAywp_$AeY6@}tb_4bLCXO0XGG?HJ}p5bw@RsW!=H+r-KWXr8GS
z)sYMo>ho~P^J5kkl{(-0iu#&1yi^z_6Hb)~Nvvq|ha}+zF>i;9V!Q}l;^n3jv<$7u
zjd_&nthU#`Zpc5M{;;L$ZF)Pb7L^UybT{59Gi0KLrwb<-J=AH6jiaYel=1k}V51sQ
z^Ts^S<4Shw_q;Lt0;>o1B7zbq*jn!7B3V_uu=4<iV3>NTv3NOVa3NREHd5IlkFxzD
zhr>Oi^Rj#UJ$g%c?7D6X?<Q>n(*j34(@<Cb7SB+L{p+nCb{g8+{Jgvb;)R8UYwPRk
zqJMt22Qn})6h_q4)ZDyzliXdfK|6kB{4J%RMTO2E93liFW<A7Rh$`|+mRl&K0GXhc
zw_T<h7C940aZTMJ2@Fz=8B%tN-aLJV!wP3Mv3vza&ASbu>J2+B^f`;i7BvkvE`s%y
zm6gTC{Wdix=NHk@(G?Y3v$FsNZ(;@xF00#fu(P|=8?dC=etApT)zuXgb#ZYqG^9G#
z2+!qE=QYK@u<yxlNm<6=GBn=63u%Rwkwo4iFBq+RmI7JWJf8V^(Sk^)@TEznjBbpa
zb|HnUJ-1iPcg9Uyqh;%J`Z1!8#aIYb4MBz|V!<&@mxiAGzFS7HvH{(EbXiZB+5Fnm
zBRl-MbN;mi9jiYBmbksWeb`z?Q<D%se_eC)tQq&_RF$QL#pmtAD!0A8z3}jGZMyQ`
z%ga5v3PlRd;kDx>0A~|awCxy0$c>J5gNh$L_GFKb?LLyN6f(}#DA5?saOS0m<vsh7
zH6~Dy*I!hsrApNDLxQkMj^VeKxe|-vs)w0b5I#3AujI#f8Xg|?naqzLKYsf3>Da$d
zP!y%0tFyB+%!Byrb`$rX{@30}{o48U#Ybc=7>5*H%*xIV$;yfyES{B>Rju1`TjT20
ztFS1^ZZsH_#>B+5w1}K&85#Zf(d;FuD&%{1^z-M>&6&Er-Cfs>$tM*$LR89*j%7Cc
z>asD($;rFByJx<l>ejF#7-I_>8)r-_M#sjMmX||1=VA6>YO;ntzF7VWg~W<y&9!mL
z1B#HXjSZ5d@6#s<ZSBOu`!GmwpjfM@Z>izMGVW!mLtqFVb&Jm_-{$+?-ro1`->2|9
z7B+O-@xfv=x3oO<Zn?PdEt@DhS8;N3daq<DCH49HcLO&!0E=dIQt=LkhN;Y9w{G21
z2(~mcLp{yXl1K9o{W=FpI)XDTz-95D7jR?=6`PpZS?i0id628K5~q1OB=Xvw*0F6e
z3kFA$dpoy$)(Ytl={L(vtufOF^O)sejE#+{$>Zha<lw1Fja%<wiNm`v6Wt*r>+bDM
zPEDnxqGB{SKMW`3sI9HNSkrFJ)W1VcK47s||6&<BfHYw*bg`d@gWcU&n1PF1bR&|I
zl0i8B`+xr~E-xE5x<+hGegFP_c6M{e9bU@T)>dDi+;Nqcj}JTG*~wq)l!5Wl(QG~P
znuZ1es>r&U8kR6q?j$VQAuE{d>Z+>yY;5ZgpZ5~OjbvS24<g9<v1k<)6=7oBw!S}!
z&_N~$dmViL`24A_Z%akRPMX(NJq)oIbT|^~bm`l4V)zH!bE3SwF6SrvFk8QW|CUd@
zXFXf6v9VEFS_)a&>(F6L?K^}5gnnvjYE@O0Qr?Ia&+sNYJG(<&BYYrF<m4=M1mhgV
zL)z3keatUWd%;E+mhz=VF79d?ovei&<DiXP99p^%xr6NL^0az+l~rc|YtF}Ap+k2e
z--|O3-GoSrhn2Py_X67=VT}Lz^XKfWX>j>P<7^Y5obO!-a$#ZN3>7N}2Zv|RzRf?&
z&t}zEfZ<SIeM}g1SC}etX7jC7R&#UnsLg`1hK`Q=`gn;Ij{x9iF0Kp#AtLN4JHEzQ
zNKi>z8FY5Oz9RToIwe{S&+Y8`m-mjnTjuAVjM*o|#kmWm6%-VxF!Klr8K|gy5D0e&
z?CJUXHG#gMt}gM!h$>P#Wl#z0dA)&1`r!6q<lDD}PLmMndAX=h<`DDVJY+F?*|qKM
zJn~If!COX<kY8K8x_C8+HzOgt#iAu@9K#X6P&p7<Ije5%H-yL0!!llSrYS_Vy}AnX
z;tHz`7MHYi$e4}2m6b{CYBlyN`qzA6nPgb#E0O+>UiR{Klvwm~*WARsdP`rg-{Sr)
zsQ{Xw&L>7(WD!!TM7rNN2}AR%r`y^dJ)rne{~{0B2R#{lB}6GiI0wg|9beH_YRkKn
z6!qr#=x9{~1Mjn==dL7U18aQmD5|C?u!ASBQQp90knJ5DoU3!B-du*hRNd>1AysSk
zRa^h>hV%XhfM0o21~$~JNh_q_4WqK_AFVQ%t6i@s@k|L<x~{PFhlt~ic2qdy`w|Dd
z{3!GK*4E4J=(|Bt&mMfAn=2dOSEj0jp1cwXfvOT=UZK-5&)I6pNme~&$D{beqH6W?
zDD(WYN%)UKY*)JQE^+;DE*%E<68n}43ks&1z1;NmXSQY=mw*4Bo|(Do-`0Hiqi>!5
zK%60?WB$*|3bUfuaOTX1OlAf3UG1(0W(wTBw{cyjJE!MVk;{ucu`Ip{^UvPZn>$Zk
zYZ%%-Oc(YdX%zriCQp-z<9vTWdsbO3DPi3skS`@-nlmgjE+OITzyN_bBNJ0mVc|P#
z3F#e(s?^jH0U?s`B!%2JZ*H7qefd>TSeW_L&%@*R=;%S~-sGf?wKWUvClgL0QqmE#
zXDuu#15!1=M@Kba_1V{!mvd4@4u1W*>t_#mJ}xm)z3A1r&(DgP&Fa+SV~^x|7!=?Q
z05!mpx3FNGUwFyGYHVaw+RLAwoXpC?0%v+N{h5}TF<~ZRMIy5WtBMvHtz2ETh$QcX
zSL+~w3@E&(7YE!xKmc0d4^}p|)z4E?y0S5l#E#@^^hzK{=-^U7i%mQ1sboHvFHvP~
zu;$u81$o<Y5dKYu8zM}FH^4=G`!*NZjnjk8s+rAbnZ@ZETgU*ve*J>$zeG}7R$*PI
zjg~R<_CA9N7D?Y;=n97gr<Aw1GL#jTc>@ox$mW)Uk`h2i(X&6DG4zl`6crTykctWm
zZ#oN5`}`g9_xBfc+j4eu+n%oJbEtzsF>3MFb(yMjocmGdm_D+4BUl{nS16GKY4ULh
zE`fOF(8^em_H|mw36SP2syv=N@lQvtI@Q0W61L$^I`eJqEly5PZ}r%-Ff=q&Qo^Op
zhVV@%Dwz2RaUn0?cNI_Qk$Q3dA2k<M2(^(_I~yBpbTmkAvUWl-CTbm@K79(r6OqBX
zO-X5}qw`^=%%EOPQ&Ur0+mh!FkQ0`cQ0OgGRfkIS>tcdTuOQ6G*{kaYr0O<>TX4MJ
zF&;a0Ij62^jBktx@K2jAnRr}j525yTFL(<L^2?I9o%0V|)`&ih$Ym1;TD07g?a9}2
zm1Xdf)}#IvX58ecDTinGlr|VeuDl$(L&=%@M~mRa>+uZz?ENNwRU+Dwgq?3$BM^3f
zvM|j?urWxcEFS8(b88tn0_XF{Gm~{SfcB|}s(58;%y(UdC=SE)H08Ek4I&B@8_IUb
zGVHpjIeS#Ax1p<P%WA*BALHO%q|g9lOS$S@EX>!Vr}n9*a&mjvSSeFW;wTbQ<~gD(
zN=(HHa2|Zn{*j)DsFFGoTCom6v1Uv-C@(WEWiN?#?LU9}?<tQ=;9_{B|Le#9kg}DO
zeLP5)xA|KJBbrH8VcgI(18T!X3&+0ed)>CA_eqf$Q`ugH)m_<yWL2Wz+8Ys2z!8Yb
zoX0^LgrT10o0x(A=S9>0#vfGo@6D#ylnEO&N{%t={H^jjn6i|Ym!Ft7fF&9!dT|tk
zt6OI~vXr{*ZTaHGeJVou8nbgs<Zr`*xSQLw1&g@*N!|LwdHnG|XQft18pzN2LoF7R
zS^FxHeb!`bX9II*1EHazd&`5j!~ypBp4R!DZcJ6d$_k2t-@j1%oz*X=;e>R`+q({?
z3By_zdcJ_p;puzaXDme*{e{Y_-;5gr&3`%FFKxem*1_+vaZVBX01sG0rlt!g`|HqD
z1>r}2xfLogp2rV}JCaIRfRppjT2WbL1mNAGf`W%WC(g>sc)l#~>@@lv?WT<CbX8$>
zsgn*(%h|L3yj`s-HO13Oyzd;+Au-%zWz8(>>+J=CQCIi&dBw+%lk5BU9vd=<&X)P^
zvx#>fwj2uQmXZO4Wl~O~prCLTNL3a+hwRH3^d>U$@Zg|SKji5AVt3aG%CR30*$seF
z{*Mr?DDEYSJvuNaMq1*R{OXBvui@mM{^=*UB<YG>GkX0~rl;$S^?91y<3~qFz<l1o
zd@Mu-(0y}zyR5V{S6D?&ZNatiI<0HtIY1V3b8{%rc}l67p9yKRb8~<DU!&qo8GwOJ
zyl1F)+@+wX=pmE_Xc8b?^Sa@-jg3u%_puWor036fB7Ohf1!y!qt*57V2RFoVuEl46
zZESp8t8w<8teUE7^x(4B`Thh1>JcVX=)=t!Z5^GJ!&ArE2A93x19|Db)0?h)Z)Yzr
zwl6)Kja+4D@ByAF<yDoHMdB|w3qVQVa21@%sIRZj$PgpyYHx2pI5@E4k;7tPW_JJ6
zehnV|%jeI&=jYMcaM!#MU`7YiMMb%}1Ljb()GZKajsHNSC64tjYmZ2SRcz6_H&55X
z26u*qt&_2kszj8yAv9RHA-~2;^n>t2I>oS9kVpz@YEtz1iZ4_+n1LKke>xTy7oSE7
ze}2o(%6c*dBup<`84nN7==gZ)f+j{_`_9gDixO2B06^6^98G{0SL^E^HVmygW1{)r
zxBLo>uQauf#+VY%9ZCv{vvxdRPCh=@m2b3JLz5E|%gzExkN$c#H#KBNe);*+L{ahP
zc?BTY*4A{9he1(*6Z7ipkN>WYaI~H|iHTj=ycyX3XYy&}@%aUuWyO=6k|OWcvfXlu
z3X0v>bb|)x)o5v|3cZq}RLDdo=W8abHU%0n3$g38@skUdNSh^%>D)T$tRbL(VqyqG
zI%)fM7Z<Z<Hi6h?W@Y6jy8+D%Zpd9Gre&xi{*OLnW!>dKeIlv6eto`~KDg{ukE+2%
zMcRiQ0qq}#tQPA)8%P<@($j+$;~FOB<Y)dL?pbAJ+Y$Ufy1#z4n2_4>Y=&~wZt~}I
z1bHU2g}M3u!GT_h7V9h&!~#Xh2c+smT`eswVPQbfnDE>wDEdMbd2(_BLHs5nf*px8
zXz`w!f2LD1zOZ0gH0HTBS^$kF+~h71_E1yX^z`)CuU}z_`1@Z;AFNw5ge(e_>BlgS
zohGGW5{I94RypL@Tvkc%-Z9_1m+KUU&n+OJr>#wjs;$aAcLut<X@Z(A&$lg4VWAGo
zQ1mIlsH)d1RwD0DSVFsJc69FR+qcx02q4G*>a~N-8MlkGW9Y8LvBI^7NwtdN-Llu#
z)}TX+PES{^Nv6S?f94KtL2fQ1KGx#z-)k0b1A~KJ%|DWp@5sg&+#|h-ruMJnGHo1M
z2Q}k$mnl*=!l)MDG1(1NIsY<k$0uY5>vvq)q#~$raZNfUEr&g;Yr8;ySI#Yj$I{!o
zskHPh{_xzKGRAnu;}GZq72BYAhGm{j_??rM-M31te3v+81AY5qNx=eN3j5u=fev}o
z;x)>I#agzyx>L}hXw0D6hQ`M2#_bkqDvw3Mxno?vo73tr&ey2ie}1ojQPy%&NP{&f
zw0C3H7qCZX2wsRdZQV>s1N{MVh&h8^wlE3BsNBCF+w!%yH*;awj!!<uj4!3&b7uW9
zOjyE_wvmUqyF1w+O0TR;qZJQ+{9A_3N5h3eBU(h0@*4XFyY6EF9AtQxnvRZ4RXJcu
zH2+7CE{SzCf+-$4(F32!#1z87NgxjG?uM%u04j5HhW%Kw&dyHX*2`}hkD={`6ox1K
z_Z#$0K(_6&K?oy(sDNxLa-2P}u6ex}8tcqVI#nXju8<^88vwrc*zr*dxj%Dt9sjlS
z=i%>6=C6Z;*8;@~X;=XJOJzM@{+g<xvgQOopp^jWqrF{h%m)%%LVWy`UG4elA>PfK
zU8WUKk!0wdAeO_shKGm6bJCD~ApU?F1i7M82MGzgyB($XQQ;=oaDT9&O4oY0<5J?D
z)K$CJLNt?aACz7sbGW=jD%;0XTu{JLHPzo?58=1Jzt3Zu&)jQU*6jLsWoYhvb}q+J
zbpRqYo=rQ=_ryB3hX-1!uo_U>s4tJc9L~DUq0rR*aVUNAmW(2Qzda6$nmcWt`?YSO
zy48AlAwv%-pToGNxc4nx5D_sk<%4IBh`MCxcTd*K?z^l!dw@$Rz{AVC54r8nDfIXt
zP*Dndj+$}1I6EJCi#YLnPr+KNDj?kN>F5ZUSWit)x0HM9wD((4fS;3%&DP!hs6Xlc
zUkeU{kAK>(;*CyBzyQH#D0T4t!xtNq6?ti%VMhJRekbZ@N&rY6VG)oF+?ihwE-duP
zHA0uyq>S^E*H*Qzv#PVLxx-QJj1#fDB*kxF$NmeANb;f6V)xOJ`-#wpl9Cc=+(j>T
zA`?A-o*&MoM@K*3U6l3ixq_HMgmgat-JfLMKi+Y|P(&8~>+!R2+=XEQD=ggv&45tr
z;v9?IBJ_muPYaGIgDa-m0ma27AFT#s4if1LDl2!PCs&;^gmsFT!lV_qe-LS9$E2y{
z6_f2^_^=?=D}TSvIWnMs`m@l^r(40n!B8Lzv$^1GlhZ{L2B$oo<hZRn!9BbQa;2--
z#q_M$Yc@E~cNV&GsCI|tIWp$pOuIeqo3f)f<VB4$Zph8X1ysY*K(z63@FaViw`oum
zOPo4hr;T61jFndts)R9$iVC}ehGsi;Z$eFy@H?uWA)>1F!v6`?FWcJbQgV-O$^Pmf
zFPcnlH!0UEAqkg^q5sQ1aOKx70F-}T0N~>9SLh&70%tq02w{QZnW3g8omu(ACkC-=
zffJ>3HwLP6<>c{$fa!rE54tU@0RRjW;aB>y+;<{?r#32cTYB2Q>#RBbwyDtcJ=;bI
zQMjAjdI9Uv!@zIT>%TW|-+1-@J;j(fKRjReiGWUpPH|nG8$c!~&V7F>s@b~PH6?R4
zyZaIujQJC#_4sRw^xoVyu5}qfQG3kw*MY_l8X6k<kHVNk)y=VqO)Qx}PGP|Qq$)p>
zp=1!FAVL50m)5jY6TXzrc}@XT!*mr|Q_~9MW0RZ}6I$fQT%V5h!o@rCdh3xv#{4QZ
zg!gr*=NV*&D_^j}a*G;!OMK6<QgwIe$?Y2A5zd?8q*6thFJi2a)&*-e45a8T!Ph{N
zX_JcJSlzJLv0X1IjgtGDQ2hqa#ABjP$nn;PMtC{;WXab<X0lxEOSiSdbM;rZXzXd*
ziy8>KQHTs-_nJmmBS>cb7KK4LMKw{G<x~tc+P}Z_;SkBC3=|JHV>YNxw5yHX{1qNr
z@v?|@H`z+pN^`cBh%NLVM$b13tS<QN!5y6~ocfH^UX$JR19MnIFs-|Fj!jUy+y{H_
z+io`%QAj`g#j~jF%E>)XPrarFLdl^IVlnh599<@yuPN-PH}#7Z$G$rAA8_FLnS`0V
z{mi<1zU_AjSZ@V|@Aa$SjSr908QAVWipL(|586x8P<usOZ9XsLN#v!Cj}F0dk5pZ+
zu#&+0S6Jq^&RC7jVNAB9+n<f>W<!1#8K2u&Tdz`|4^bbV`!+23Y<n3)w>@{UIaiuJ
z1yR0sm-_g%%`Xn$op27HRrw>7-(iyV$5_k+-DpH_Nvls+KYeb(JDVp7gw#!0rmrcx
z(6xl9NF}3<bzb6kq^Pm_ccm*Om>az>;BKhCu7AU`!5*K1NOGr>`r;31>rt1c-QH57
zvG4IxVu8U-jqQY`$lh&laA3?ty0z@3mNg$t_xInJiAhO0{nLqexqW%TAz(QZf^*Ei
z@LM-H1rK*v^Gk%(U21#<BI-p95-<50QG1o)Kzn|tcM6OL9FeswC&`hl4uOy6FV6-q
zg&>)Q;8G5^fY!cOpzO2OMQVJu?02yY^)d*5HwWJE(C_kawbAc5(a&Sy)AbY2?H|pe
zXY+WZ!V_LU_R<`E_fi14?TVg{h|c<5p4)lZ+OGSZeepXx`XYJ};&&9%(IM^~dj*k_
z?$-2+(r=f^Z#TZon*rdKLr-7dX|Hz6ZU&yu%BG{A;0aR+K7XK3P8i;9$Lk)__}BCE
z_lv4^wT4Y0yj@9*X1H8(Vsu$+z8G=3)ZF}Y?0tEhetBFG>4Us~Uwwa^wB-**)zn#@
z-$~xw`IZ~%A*ltNSJuXg8r`-TgUD{Ynr(EuhUWkIvlMGNFsv;r^`4%dA}2$UEdcu)
zp3Qe$6Fm~E^?{mbe7>fQ%E9CjpE<neagIvS5PYK0#{d!8)O6NoeBlIqiG#ydV(Zxw
z;8KWfAfYq-x@-Fy<timdQ!DFKwTp+P!Yxv5nWz|h<Cg6?OS*DWSd?>!HMN^Yf0c#Q
z4e02+DC$E>s?y7z%;Whz;NseWad_=l)X?BLQEG^qoDHaG1|Odt?=GR>3V>C>i`i+h
zeM@UAD<46dy-o{O2}(-J@U*Soc(x1`V4%_;zR1nbfBlTM3s~(Rz;YX3?i;&pOsZ;X
z25<8rOkyEr?S(3Po7&kG!<(!dU!F{~UhKm=R8&+b1HShDhHvLZ$%xglU`xQrs!-FA
zB-KQa6R+ZZj-g2xSNJY~?~YvLlD;}+noQ0rWBG^#o5;2ikz_+^>n?lhtFDuIl+4_E
zKGT{i;1brXsi8rS)d5XITkU&Mzm~c>ej;oTFqT_Rw;G?#i@UiURt<`r&TjkGwX{Ho
zbg?aqeT)qNu`EBIGfCkra}?Qi0cbQ@CcC`+nUxjRoIawB(bC3dZ6y8TFATmps-wA0
zPJa3~PjqwNbLjpI@2SmoTLK4}3QW!2kF4zmg65GS_8J2h@=KL9dsk{O<Zq>>COS-e
z-kd=s_U%KnzI-eF=u=ND(-g;BKntI4Dd!(F`JQ_MeFJo#{H61Y2NZZBM?Zn9SzI*R
zRX;m$ygY~n;MK+9``pCj0}NvN#cKMbK6pp|N`kSY#|(g6hxQ#rxhBszljw0zna`$e
zCDQL?B>i()nf?17r3AxkwyC@%vC@^uFVH(9KP#`Od&saZP@MVOSzZLYW*rc1JiEYP
zpo%QIXV*y5?zz)N%EZK^>tNyM*E+L#u_7&M!%6n;gf<AMc?w}qXIP2u?hmLUjq9D3
z47WWefVCpEpPPU7_u#<Q#ih%XE8aoS_w3`4RW_ZSvop~FF~X$Jx>(tJ;g*Uv{Xpz@
z{=k0I-dC*ID~9>QVYVu(^sY3sN#}j?bhW9D68m%qT9Z;2I^&F|T(U#OC0`R;{xXP+
zo#PlE1<+v4os8Ehr3oFM?G0*cX%ULwGim}dVCu&Yr9*4baY{>DypMM?Bhnu{?{KK|
z+lS;jUe^MSCsOR-l>>L73xH$Z+g@{m9=nTzKX%@h`JJz$f~}SWEI4an*~UIY#@k8p
z@ikVs3562NF~e_G92(+tG>X2LS3lQmi7Rv>wvAvRceO7(qUl?gt3G(ky2RY|I=j%5
zM6hgJNMCZb$B0_c)y~`7TQ)?H;w?G9!%uxEMJYi*q??~H`fb)s@QqEk>njoObkOXJ
zm<<Q?;>8onRLZ4QYq->|QM0Cte_ac((Z(AkImi}x<tV0^o|>CJ@(DTnp4DEf(Sdrk
zkWKTn-)p8+galP1)r>!=0BqqwsIwL>dY4>g7g5*Hh1T}qXl|ab^Of4tSU2<kj@{W&
z{Eul+CdIO1Sz-k9R+2&?v0b$VrKYGx-Rc_CY~gz7;!tKdVW9=@!W0Tc$q3YIrF?BS
z?IIwQTu}>Mh(^y4Hr&ifv8l~xl@n1_&pAWgK8n%F<{_G`k3up1L~1tu7`B($(2W{%
zgZrZ>%@#plNv!2C74`IAF&;NCDF`cxjUS6w9^5iY`>FrL4VFq^ds~?}Xu>9)pABWf
z)Uhr~^5J8rz~Rg43;u+!rE09yn}vtUoMa&Jx0~R%PN2>Nn?Z5@E=fGDzGu?x=H2q6
z{dc;CS0%P$unIK&&;r^`pnm~c=>&yp-iL*S0Vr~bRlzqZ6whkFK(8$i?CPy~tjGQ<
z!}v)a0Dd5op*Mz{Dnnl>WP1lt3-;YW5Ej5;_G_nD$Pm5KIvCAXKNxGrtoRw#5_VE*
zDzwnhW=7FpZw3Rxx&o2}m<<#-yGThIA9!V6qnQ~r?5P#`b3H9@`Bu3QaSdy&u@IH9
z4(ik9b_4uRp5L#|cbJb(8!Y=qjUQL2Xx^06;UwmLB`OW$w(=H(jApz6vm>D(Fj)G(
zhDE#&WZZn@bPcG1{U5&arAYzBBP|9OO38ZwP*bHN%oRe!SEAb5(bg59d^~>K>6y0k
zADLVK+;zNlPAe7q>MZF<k=^dQDQEm;G+15-8y-jVA$SxI%KZ~7fN&ZfRy+F)E~y7P
zkHS0Wnc3NEW;QEyKwY{3vSH?D?*FLQ`agd9Kpz5y2m|ekxD0d=V9S68OX?E4xTFL)
z039O^Xd)kPZf^RvreEk785x0swbUCA!X1bQUw-WrX_t96|A<)Q$r{p8SATJ^F=fTm
zK$4b!Agk|cKl6{8m>wU`^-2Yj8f;5YrJm{o7w);gruk3abL1ogF#%ZYfNc>3;CD1z
z30Ya$r%!)@77J=4<!qg_uv<uHbZqS71lw9*;D0YI4N-$Y`?P}Wl#8F=ZH)KZ{`v$c
z$pb0;{3?b7;{6sc=n27)XS;Kwcq`U|FNKtZ1Zeq~J4q=ijjo%?bK4;eXsDriS!_ND
z1WQX%k*&A)dwjwOsb$c_XL+Sz98KzG&V4Ua1>J<G@F>S1J6Bd!L8I*FC#rchfQE;U
zkA#>wSUdw3Ty!*nxQvle+Q@2uPfrq1`#z@!8ym&#Ciz80Y%DCgIyxw^8IG)({@>a#
zzhS`is<W1c2AGju8@IpL$AWe7+qY-G`)`ZOz{H!IFTqSOVu{17z{Ej<?wNg{?c%~q
zYX)rud_o<V?%vHRExiZQ+4}yE1{XHM(DHBy6d<uc9>@u^F*Ac27)1rX#R8xB^mJo&
z^`|v@hW94mz4GHt`BLyG1>%yDR`-qt1O+?i|6mhG)^_4i39amV0xt<FF;p*LgoIsS
z?*0!^-+2(C4Q94Qo1H`+IzC@t-v<;_w{K@0%7|9}{%s)}^OjmvX%H^r<>FEW!v;4u
zHz((Z6Qr3gh*c%P(MV-MuQ>ngV^!72sxt`@QIL2B=;w7aslBlYiHUVjzu<;<E$p~^
zdU>tN)xpcI14&z0NEh^XfB$yGXW)KSiQp~30sw>?2=x-G&hP+{Ok_7)-P}gTseF&-
z`w}@~bENZYDC1XvHquvDj~%l~O-cE6wP5-JfC5CsK!5*VccD6mS-tsApvD3*YH#T3
z>N3WLQe)i)LM1RT5as}wK6qU00^l~F{~yUy23?hppWo8loIw14h4hAo22jU=fuS`6
z7zipq@Wu_k=K>M0p=jwN6JYwG>947-1{rkhHb_*B4GmE9thke`?&5}IWo9mbaz)Bv
z1SB_r&a|W?sPBI#!Rq$xfr342d=U>PCnp!z(8$OOXzB~Ys_PzOSzBAf!g}!Hw*n2m
zm9_Oe$LIBZkjK@gNU_ij?rDRLr>Pw+Lr;XQ`%h!Pfs1SO@fj`1@zBpdxzO_Sy95IO
z;0O>Mbaj)X9YSu2LymO-Egl4KU@i6a<<B#K<N<wk?&I^U+}u}2?6lb*KYna%OxYfT
z^y4n{V|?6oXF+oM;YI>bC=@p^mD7Z#CMKjE$1SQ-g}q!&Odg%;a(X!eyeTQM2e@&0
zaqipN3R&gXPPvlOMYg$_84o`{-i;g8H8sE(15@3w5W<W~^e~Dr<8u{HLuMUXombVM
z4#fWiO9;3IZc|f>dhD7hD=R;L&K3V|)YibrKxam^VFKa=;MeHrD7j-37a!ke12y|g
zK;kerTU%S&#y&N`9fyIf?q!=Cjsl~4rX6|NgrKl6WvB$y4aoh(k7DS7fR)Npt(yV6
zgPfckkt7QX3#|0(!6;J&tOwkXKzu^%;N87F@R@-uEG!9`%F)sB0Yw_PPEOAiu5f}7
zJh;4fdJaC8zi)DKa^NbFbPghHa8v-lL?8}x<n-bNgDiK-0JH@kKD_LuF=ESh5`>ip
zw?8}t1{$RB#@Vm7EkKvY_5f{&gN@x}<Vb@LZWxQIhtL9fI)dkbDiRPaD-rfhJiL*<
z4@{7tz`zHhBe*;nW38vs-#Ubh)P4T^*;~YzlWb#sJ!@7?O^sVfNJvz4d++$W1OKed
z;d_V&FW&#(fKZ_Pm@v-_Xtp7;_XkxUe&4KVr;G0X`4jqWA0Ho3QcX<S?D+C_vsH0=
zH(lXTfBY~iR9V%BmxMo>nMoup&Ck!9aIS!c;w##W^J;DzFQl{j5^_m_OZAOv${a6y
zc)kD{AW@k}!a;BP-D!O)N)_2x362J!xFP*=8R8%w@!1qmRA%H1j#TxF(Gv~{$i{)V
zu~n)eqX@kkxBzsNF$2XK(3+UTcy7PP7Z1jwU4(`Wgk2z_d46UxhtbPQzonSJwyp8C
zn+Q?UPA{7bNpWC+STcGo1v<IJJ_anbJ__X>S0J3H>_mLe9{9=H@h87R<wzBkZzCg*
zv69l#?y<1IMXB%JeK?SU)h75pm{eB|f50qLS5Y?MhWzf&Ro9Peu4w*<cy6ttnv4wp
zfhXCd1zx{kr2^HBVo8zU02&+^U}$)0!pYpn-AJ}+**;f>>;pSZs{DS0{NL=I0qg*L
z+>j}Uv-m2JICI^`{F1&U(9lu0M<Sb`-^na{vAgZQ`z6vag<ke7q~o5#%w;7q9Xg}h
z+JlSJZEAAzr($LR;}TT;pUTSfjtFa>7STs<VSS>Gkr8JJ%WNPU)0^68ldz@9?R4x6
z4#v<;0K-sq1^MP?NavFuLghM0-&WB(5xtebb&2sNbeU#^GFBoF4-fHhakr+b@}SKE
z)KH0R-T6#zM<%a&S#jUO%&fbTB0{R!$kE3~xTXxuWCIp2o;;cF?^oEpqIu|g=6eaA
zvs<Y?U=RSA1c-J%5s=lNJ+PvPr4kVk=vDJ`FM1{Hn8{o?N*uvn=~4sN$KVcaK69m+
zkx?eV4bik#mVH(a0acWnYjL<W3)#5u0;zS89o+dOWgvGrPW~M2ZDiz}+nf&u21dI{
z6crVAuse<-K6-3VHbgYTP|XfC_UT8LQ&A%9*(Q$>JHEQw+LLqN#J=F?7>GyX0unM9
zHwUcow>w%%B!^5m%l&R;On))q{Bw%qChPoxB)4<;(=d##Etu0-STbIr@5xm6fBhPk
zDf3hrO!*Lrj7Tpbs^mAwFjEhYhqE#-)UEKt?vRg+j6e)Iis)zN@6%R;QWzf}KO_vC
z{pt#@pkPXL^pm<7YlUy?`%vm^ndX2n2R{>i1V9_P7!570gWq$vlF1K2{BquN7lL>h
zvWjEv2I~*#QjN2v0zyFj<F)~b-fp52Ke6FdZ)0m)(31#$89lw;;@nZe_xNfC1`5=p
zYil;sAk&#?Y7$rZ#dyDUZA=xJ0pQgCLGOoU#V(V*jZN6AnCrAqig(-%1W##+cli1F
zwY9asoLG8#PMcPs+#%HKYilsMiOEk(z3d?kW-?a>2^}D;PK{%-VXjY@Uy0MMt!@5j
zPT|9XB3ko%EsQ_ms8!eHCR54ZAz_IG^Rey>Lgmpp(~zQK+|AGS3Xm{`s2r`VK3p|&
zQqRlE>Rff^<K+br`s-JvJC9bkwp;~Lr6Z{{i9jNGcagN^EC3qxDznn^&d@B1w14yF
z4LmUz!Po^F@bK`$Gu{6w4cuH@VkLJaRl#AA$*fW5Aw(6@nL(`cziyB`%L#z3Yye7J
zTwJ8GhBjT@TwP=8lvYV4pL=>He~+Mmb!8y}lGI$2M->!(xgJPw0zOWFp>lG%Q2TeD
zZx)1vgkXq0@IET<G0VJl)%p~GH;CGRDl<t8cX645j=Wp0QG2Tpb%lmrPmU7d<~HRd
z11>^(<WHGlV}eWp=w4I;&aY8ebE>INa_Ahjpy8g7C;r!Ba_=b`&FM$C&FL<)bYveO
z?}&&9xC6K&jmi!|k`Ic4^#U*}u>ITcaHUla=B%wcQBGc7UQUiAeo#`<ZN}B=bJ&xl
zucw#){th*@TjMNG&ft<0gR;+6gq;^UpE--_30AD&D4iVP=tym+0mDgvHeUl8Tj-yK
zte~bgQ*L>4m5MA4@vs)yqohi7vMps@yu=>=VzHaxV4ceDDK3@J18(lh8+g{_>Y(sy
zXv8%bp}({%Gaa)0`d(LR6ypVl))omDZM#`u>GP^m*)8usZ(C#}O{^(7Fk21x15&#o
z*tS0SWDGNd{h3lNIu!A8;3WWN(BW^LLy0yaq2+iNlP6peMR%Hbox3nLrtg_iPiSVh
zz7}$~+laF!gbA)t22j^I{|-LM$>NUCI+e#ro;$PiYECEEH1@tQ#iSfD>d?<n(#&Lu
zASa_hH&F#g*3k7g(9hdNj@`e4K(E5;S<AV-bIIsdMVMn|y~#XFw7<we+pT}~?a>CR
z-+fe@AJ`SAvNpBT5XP#S*}&KJ29L2)*agQ*%o_D~lcHBxHP|fC7&*HQ?+7#1F>Zy@
zmgIFw<7o=mbu!_hdT<1qE%7MvEdlSX`dYfCLXyW$RdS8dsgn9%#9W5y^`P~H7tYpd
zeA0<d(%OKlDMa6{_K^O$VLm-ClZG#`Z8~p0TRA>8sJAEy2A9MUxs#+8`kS~An~gq{
zvoO=2RWonDXt?ktxbdMSO=&aLB-W7UW-?~AR9%ggaI)?*XJDzr{%28n$-Zi$THnc<
zcWWRyu%W|Nc33)PG(OBU5c(nLn8$Gm7<)1FLu0dr!}$BPo*#>%zVfA_VXl8M4Y}z4
zt<}$TJ-P1#%SX35l2cJv@Db>Q-$VO|i*0vRALR*0=oAh|eS`g*usiM%eoa<G)L&v+
z^n|MuEWHN?8@CUJrS{`H=O0<3A=+|HfnVtf44`px5|hbK4<h2xx$`!^xXy}iXgZwT
z`f+uKKoDhJtc702u-@khP)gf!$;BjM(>NIDkBp_Ya*8^iYpb$gtD1>Lt$u76zhm1x
zL1$pZj%mdKcej3P*Db@EPB=yKoyyww2@AI>k^d(QhEnF|Vxc$^T0|a-yb0B5XySDn
zOfL`M-OHJ|Si<SY<;3aygIAX&2wsaXe*ExBl7Y2bl}`G4==GrDg3mGIx`tvVVtg>~
zI+)L&CZq*2L`j+kq0!PCR+alwQV_*`{2;O9E<w~mM<9`eFG+wN%xp_67(Xs8WfE$R
zg?cPAN!)}8bye|&qx2{hlbno{9DH#i|89xUa3>8Sar%2d6rB<=bhTd7*#+tbsc7RX
z!!_O9FUpJc{3S_<b;Jb(by{%=u$>GDvcgPgg0RAhnYqM5S?KTKn->YdObp+k>4QtM
zIm5r@lj4uAv0@=hA{cN2kll2uuT5U#$Z15~4ZtTrkB)kv8dUR5hnWYpmB8*g_2(!B
z?e=!LSNZt5L=a|`rbHN7bYw)PD(GS=LA+svaw&enEfM>UYQ+;6v7k(~C2QYRmeju9
z-9B8VnSrlLa6^Lgn_nnRalt|y-{r!W^}F>kI4mdkS|e=)%wqNnYot-p^0K%!k^u{w
z;57}iZE-1IbekzQWBvQgvWa|bA=?DethNlr$-D-ep`u}`@GrpoAau6JunHRJIt&G$
z-83Kn?Np8~hA$aiaNB<AklwsnjVmf<`vaklhG>O6p`>bEv3AUYQ9}zUt3T>y<b~Df
zmFFa0N)E=MnO2-+`5%VZFG|_}MoARpzhM~vo%!{)pOLHV-$IQBxrC*~8YT_)k#lq1
zSD#U#P|G!JQB`&W^C~fqMt};t_$9-2R%?d27-k<iw(@sqvF1svwBoPl?<tsYsWS9c
zGKaBV&*$#fU<W=#lJ_=z0VE?W^{1--ut!7lzCyUwU0d%593G!kmQ+`_%HqW|#tQC*
z+AofcWe&-b=xaz)WmKRp!YX!gDrb(NClH5QZ=38Svk?1tAsM7H<5)Iv&*~>Nho}oS
zvIO^@NS7S_s-YY)YY6?v;Js|q!>j1ppq5lULf@lDlTXPhwTUnnE3jbXW{}uqQza@0
z%}JHaCo}>XiN6bX{?Pwlz|)j>W8TBfB4loOsM&CPy|BlV)#DSAx$;wh&a?!ZJ-0|}
zYO62(zkR&;I^>LnI=c_jo3ks+2(4*+`E#w^c@x6EsdinPB5{>Pisb80hnZWg7Ct7j
z`p^6GnFv2+HMeqqt1T0ndu8{EU~*oUpuXJ}Z8}ERg`!ca|6F%nztJ9{N=rEFbT{`@
zO@ZNh4_F&@w6&#;FLx7LDX6G?f#$WX(80vSH1gTkY&b_Lc9WBnz`Un>t^v14cku@p
znDooDWfcEkSZGS_cd?faJvyN{v{@-BsOHIzZwBfm>=^jx%TyNH3F@4u2|`En2S^1d
z0%(BpPHK<EXlQDmJvjURVvr?lczU`4jHVaa6*?QR`^|mO>&Iii_sPkgt2v2Sv_KAk
zy&NznxI4ioXJxelMcJ9!GZ=6RlhXSS)FU%L4r-x&UrzISi*H&tqYvG*ygcwL@aW)|
z32dinxr8wq?r6{C4sNkn64s@E+cfrJSkY^OQ8KztKxc!f@VjeAlIGclq_~U_)iML6
zrV`J?H-_xC33%$2rnd^ibk~tpC<>u&2AV5D0Rbr~smTL)1Gwwzs<rPjK$pZm5K=Vs
z^k5s`#=a+bNG2P>ZUp9H{Dr;a{O=ySJxq#>BO4ob0LY#{uNbpg(g&;u{tSStu#II<
z^wJwiau=n5fzTsE4{Q<G_N1hx4euo)`=H-xX-Vs4)J*_#O(|7iA7sVB!NGLUZ}4FY
zz>kZAI(;NbVjpZ3`0XqJ18|*I;VFUmKPKi@Yw+&TuSjqefeD<6jScYqZ<IlQ7b=KM
z7Cx=!eV*|I858RwD*DQ->Pm%pqB7y2x~wB{gF?;clW~t2%O~|WkVthShS~A@r-AK1
z0f&O?4y?_BjT7qweSM7}bNT(vqTUglYj6q2ABLS6FbrT$8yV?rotc`FeI`vI{6AiR
z9O9)v^PRvH7Zt68b+RF^#rOOKME9&nku_(57fw$3?~00xdG162;RbFWFg)IFmRD6(
z_3>%`@~hr?l~CB*&h8C<WqJ7{<>}E;Ggz(Ht{HnQ5f>i#uGje%fdi|mD)xsq4L-i)
zbC5xyN7ukoLz2kDh6pfX1I5|0hguBxB)VsW0x&h-*1Hy(?7nxlr!1DB6*tl=po>3S
z)iEV0n>h-*(XeWsLO<^V2A$=-hpDjF;o*Y^?-o>nHOlSC$;x`1umpRxb&#%L#F98A
zg%1fyLPEl4Q?B1ZW22+^;_zr-QA|}@ULDC(--rU1cr9#*T9|4O+5~tf=-(C>={J|z
zv`fExZ8yW~f_O+F$Vr3^sy6sY=6nua+}!rs<=}x$X0VaIV`lbi@#8JShVc(&>s@EF
zoGtIJ<tkXGj77+-ZDrZ$5_^AtbOW;!_V|FO4TwdV$4&(lW8c0#GB#**Ra7OCjREtu
zxvqnajez$NXLCDhgQndj7?R)N6XJ%zrqCK_{0H?_RSB@rn~b($yub$}DcSYs&ofp_
z{*-}52j>_Vc@+%}826P(*ijCAAW+OexA8lC|0#G3j(VUEp@Tzx935L-H}ABdQs!`u
z!qxCk1!e=gHqzFKpJY|@3%GNf6BlHiWc5<mJ*dv5t|QY2-C(N*a44@{y&}RG552|Y
z?sE$}IR9hP`}a+r`!>+{jtIo5=PAJ=Cm|uJ%!0ip^s;(D%RT#vP@Dumm8`0X>Rvzi
zF_6eVF|f5ey79g&u_S0*ev8r4diwguDamPRBF`5j?Cm$B?@9x%UU8}ik?GGlSQ5&m
zUYp$y#?l<(k$V4F$)D&@;YV&voVjslF6%f--UXopi2fx?k^A?bR_K7uj_ct=kJaIv
zM>HR%pMd8bLMoG4%`d#`8Z6?2t=V;F0r1hp$FpEtCH6_87{rYEiT`>XE5H1jcOxew
z11t?79DIX}ZmI0xuf<wjUtfpjG-z_u)%zIAY7~#G6BEm5qh1=1?tT`DOS#q#x0VcK
z9|wnfw4Z>{oprdl0~;N{f&gzLlkhHZY-VPC@Aw`#pcZ45e}LGpl=s5ILaInlLKVz4
z;41xRqvXir0IKQ5ps@5NgPuOEYFv3{W&plv)fC9tgUj#;Fnz^^g(s<V$CQy@)HO93
z!c2h`Oi^fi0HolEvS=#k0|O=C!mn%Iv<E`!A8~t+BpeL=Kl|_i5r&Gtj*-IE+O13{
z?<zE&dFA}{pIMiS)(q^q8kJFXN;gIYl<A-2j>9f9pc~|CM*sf(i|6|%5ctEUrY2ws
zp%>4{pxso3mMkdhuJqdnsY<djus(GDIGC8c{9aR|F=<x|?OzmrOnkiLi+T_pz}hte
z3Au6B$k327ysOlxxlqs_)o<1+Y~|X3T@}6-z5$X1DBz^XZgAn#*gF%`O3;SUsYK*3
z+p^XM6&DxN|9E3#F0A$LrShDTkLS-<L@bkbG0%h9g<#(Tbht;E(5mRoKYL(A)y>dK
z^#OxViRs7g_@;nk&KLrTBd732`o{BCS^*A8pI4JjWO!jtLClqpVlax2^j4alX6hXV
z+nKyp;olZ4kzts^vR#D$`F3bR6k!9tgsd`|6I_n458VNDICAfqpPz83F7j>?SX0tt
zq`XM<-lhCr9IucB?MeB-rG)lEYwZW32;&?q&ltJ=tf*R9ZMe({U}q);L0tZaPZ)GK
zVI6MY6BL{**$#Ku{^p!&Gnmr`Zvp6{=^py@{86(`#@96QhH34v51-H<vi8z)QIY&2
zPz}W%{iHVDI~B_(q1=|OTXH)b6~yRVRNt_XPgMQme?Qc5^whwP{*_5c@aqW|712^T
zO{=wOiD8_I9<_B2>&vv-iVn>()b4B=#VAu80g^bS7(rSr0w-BZG}YJeY6ekR@Qh34
z_;@%@aosyL;drHPuT?ac-qRr8CEp1Q1dD$geyZ|<<n_=`x1^%@9|t|p{3OA^*i9hz
z_PU$~&F-w+&6&(^%++YlAe+84f2gzPiA$o}pGr7vXsb$`(~TC5@$g>MN189!qhqx#
zCmn1FP)PIT%CZSY>}s9_fp|dc81X%oeEej$eT#Zkw159En5e&Ll4QC<H1Bw>$;+(Y
z*>WT8QMD3fruP}AllY$v4%gRBdSrk3NvPxF<O|5jj&!A=@Nbk|MIybf2KG?N#9QYd
z5#kc0a1fS>3F?msI~#mD`jiqz61fJbx;kt4FR#$~V33HM5><`XPzHZ@g>%@b)wuA>
zmZMn3^z38G(BH8AJEp*8mOU)GPE$pnU!-_C;15(90ui{8TpFVgwfN82^@#JoW;~jn
z)M7=x+cy+6tgpf5l0I?Q5$9FG04>XIty}laIqc&i`gKW8?w?)7_$699Fsl<%arNmI
z<LwtYE{!+67yB+GGMb^zJdTna(HWp_EV>Y-yOS^>-XGT-HBlKg!L50a!ti)7e)gC@
z`jfUufJyJ@@4EXaj=bmEBV!y#4C-M_-vhAf0W4d|iT?v`10YR*EbrNGm<#Ro-v`7f
z3e`=70Kvy}Mc;7n!m*!3SSDypCXe7#@b~7bU}^gosh?lF6-a}$6Y=H^%}lD@3Qqt-
z=>0_#`|PM;b9U#$`-4IwqodWViH63;mm6S90Y&!g^V2VHg-<uCV0-Q)74^WcNYR!z
zSs-~PM@Rc#BY$Zhn73G=VllQ>d%JqVOO8rET(mWjD;E(!?^a&$=ky$yJ<QIOSM}{C
z%p4qe=x8(lA6wrYj^*3`uTqJUl}a`tGb1~qo2-z%%FL)FLNX(XY?362P*yfcRtO;^
zGK!2u_Q;6%zV6R+9KXMQ_aD#kd1PGob)VOHzTdC)9-U>RY;@ZE;KZ-hplGop-|=z#
z;Eem$mPzrn`<8Ew!F^^f6_>pOao`q$g7#dX+q-w~z`($ZPJ1ZOAk0RY=rPt54N)$t
zT_$PQrr{f80VhR77C#(w>e#i*A9j9tECBEaQlXxJowaOWvce!+-|LI6)@dAVu=+nr
zOq}}T30cueDJfMlDetu#pd?{&g}x<0)Xshx1XmJ@1zozIfZ;b*=eB<e`GM;_p{jHB
zYIfHo>~z1{lVR4PCLP|zvQ|U%1FX#tV_#$0{ING=_KUrk?~h$9_KuDR?kNI73Q>OH
z>V@(Mcee;f9N5g{f75ore_@(Q-W=lw`|`|hYaR7_r1u!dp1Z?D{R;HnVanDp-{G9L
zG0t%Ljj9gvniTDcysh7Pa>$tYH8$owdTfX_&>OX3($lB1p34)kFc_Gbee3L8K;aJ@
zj+UsX9)t%4>js}Wz}sOqQj4w;XW0VjXoXZ-zNh?tFPD0@&vMgB8d+>Ox1U}Ghm|bn
z^B3|vLAWob3nT=la18C*O9`QkS*7QxBm1GEhS;qI_aG0ioE)1SleM+AkiGx4#+!mZ
zho@?t|G4xOoI2o*aJt~2L5HD{4MAD;-)1e}7zpU^KE}IQ9rD{o8)J?}1hxQ}4_Dv)
z|4a^J*Cm}?U6=90`Z0;nA`Y2ic|rpJ)o)3{&$?^?Qorw85Olq_5&73(zS$5eRJB&M
zT1hmjpln(jm#Cg}uNYc-wu;-!!WQ@rVyo*84(lHzsurMNDuDH3)pu@nqT$_)qZ84|
zlI*k6*X}cW6Y_JS@OmE`REhVAKM!{u*iyu4%=tl@D8JFyP989y(C!^X6%!x7N|X+w
z<n~*!^IL%$7;9}r3OAdkDa*X#!`TGQ<&&iJz0aVU9xA_ShXMfQ>Eh28uyAVhz&?9=
zdSDb;TBlP&75*85L38t=%}s9u19~>X1-c7#8-M>In*tKwPJ0O7Ve_$bxbyZLHL(Up
z!vtOs>~h}+5S&^>FAsBk%jKdzGB(uIQ-2_U0v-)djRcGC1?V7Vrl-M`p+16q5X$=H
zT%u0yjWb92G1s}uRp0H6Ar?55SXj2Pa?VNMfx(rbk{x>X^y&1(#007rN5^jFjgGSi
z{|#;b8v<{AKPc!Ds#~lQZGZg6KO><+ptP<uWO^)jo`YQ73(RU{;}X8y1GD(}_#jx0
z>t!4Fp-;qn^zzz(<b9rTXTF26?g2WpnJ<Dfu42BI7+A@u1KjGal)N<){QE>X&uA;^
z>&E!<BQynQ1Mq`cm1{!3VPF0_m7AFv&Ds3ZrQo?~%nKMLZstxXhc>w2vBWp$<nSv{
zq3WHuObVWjJ8{BJJn_JuIvDo*j9)Qu1cC(-T$Bjp>7Q8v&fUF*l^MXgxlz3>Gq8kD
zsNWhKxBLn;mebZOqZ_>3+~+DpwKO$9)!y9;SLFrY(C^oipFOiR^_F8<8iugyfC440
z)qrj2*tMKNwX!fTvK+DFU^{JXV=9XL_OXF>$YPv<;6+nI<EhN8PrsHbu_DK}RoDYN
zh<*#SRH4l28{N`3ew@Ky$<C{SyZYw#ztye>Y^VdXez#T67<r#$q--hNgm#Q*{PflB
z2z$lZR5-n~PEJmaC9#j#)@z)DDNcUvuDr^kOfd6CNuEz`c6R8HrMo*;u|%^!E(A|X
zDzCsb^caBTt>g=HP9ffAlh3v4t6kNt83yx|R5kWE@!YEod!@+~11$!iBT=7Ye=vfM
z1<$&%aYCEzK(*g?M~5~)y)F}4<@dw+?Z5a01#Kg!M?WRWK=lN6L+?$R$HOb_9<sB4
zJdryFz~UB1$kC%m_fj%aDHVWe+?NDdI_gxYP{8n`K|g+59@pfxxzIRS+z1ERlk1EO
z4A{&5zL5XRA<h&-e!hArIWe)t)d-7cZfka~@G+MUQHc-N>LEHh?f4d}0stdW!{7X+
z`E~&607Phf`21ypSnX=Qj2+ZdRc%J(&Vtd-{Dj>-<JZg%tqnX7t`*y7_P$o_FtiZH
z27ge$-y)hHgoOT|`Jw+TO8<^;-`=67h7&370ec|2A&<&IIEmv#)O{bStuo4auN~Z;
zKZrJzs7uL!FABGc*lWWrH9c)31AXdvZ-KSe=|6OA^}m+>LAQBaJ(K_Mdb{6N_4Y<J
zM|6{r-@5vv{69qLaR~RbHK0dkpt~Vkjoe;~1nhz5b$VvzUpy4aI0)spm*o9s;fw@`
zMBKMDUy9O)68A}LP`)cT7hz-b{mEwzjoO1$?{U#&-1>FmKS80~_@5ei5`{gi9ndPk
z2c!WkpwnK~=kGE$$Z-6AT5e4UfX!J0!Bst#^Le5s1_f$b$Dc()x99_VGaqXXdLBlv
z6K&}stYia&jWoT<<C%IcP<uNntcw)RcG@dlh+vcwk&}BS_j;fLx@7n>nH#2dkW96|
zS@L<|=J)n@o58ogYRyecHj~Hyx*qoJ{Ty>uoopYM2QkztA@9dW^XipL^=@xOE+tO}
ztW(~((KiK<pmboyAo~wUa=GM#h!M(Xd$`~C>+dPHY$is2W~qXV(157ia`FQT!8eW<
zDaZ0p#j4P}{-dM7cYEiL;oRMDFhBrOP|$fz99t%&y5v4PNqQd-CpR6KVL6h${=DLM
zWy_`M^{-6}F)7=EQ`;G5Yzh?wsm;P1+4Eg5^3A+dKP|z$<=^4Mp!YGz+|T3!-HO$r
zLvdF^u4e5vJi^^Q__%QSY$*$l>^Q?qwGy->`A4aKsx&0|H79xc^e@<)ERwd#4oN7C
z7yqa{&QJ00sDJIwuaVboO7sX;WiY&SElP@s%)QFgq%LurJ2!KV`#~yLVa{fIF$SX1
zqvp5IQqjaHV$YZX6o_4XlI+o*BP2)m#9nRpckc4Ps@KmgNZGwLU>u0uV--JHc09@;
zK-qSmdbBwT+@75S-@?1Qm9w9{O;dYpu$!vy&MT&V`U889mkB%?v(L}?%sJq5fQkPK
zT<p+noacgcBZf2N`dD`ye+%S1G$9=`-Z@e29iNq-xV?y47Rd4~W=VWqW7p0y_m=v6
zp?uMh{l+^gv(I&G_N0##gP(V5?Oat<J+=XWzNWCzOk8ileV6=)<44KeM%A0GPkE0=
z&dNDFQz<HCQ@lVIuKc3e=3`S6n0)A0VmRY0Ai@M~+{12lK~e4<&~J~+buMdeFC{+v
ztl5QfHtic_VYNNinK5y6{V|8oyNN9b5>^XzBwqXe%VX7EAh2k}eV~~o7rJCpTaPX!
zisySmgn4VjbB>2so~n(x9sjJHwQR2+b%8Ip_d1_entzQ6!Q$xtJ$TbtBnEt<1s=k{
zofXN#X%=J2Cx@q<FVI1;vczJ<?jL6_ckgwLl}<>c!{ULgrvjd2O9hWEevb>`zIQ3?
zw@!23jNk+>?s(`G{<@26M-WuU>z|(Fm!bCgvjIy7WoG{uo5dbFhQT?2-UE#MyhW%k
z)%JH@o=)w2#i`mVZS{(j9w~5ks&vX<c(3crUN|1pyIXW1Y^LUuA`8=2T1)Uja;K8a
zSFJP?r++)}zdve%KXzs@<TC$eD#H%9$~|$$O3OWry1N}|etH$KYCXx${*$Pra*AFl
zv6U{e(b)5m`)-obi-|0aeD)Waa!vpGA2!mkEx4%~lSX6Yy&NUpkez*5{!G@qd8&#y
z3m@lWOBl~tcl$RSG#$%b*LmAj9^;|MYyMy&x3?~S_j6~qK(h2dt?zUXUDdu^cr|&~
zcaox&7u`vZpC4dG-e&s_y`#3?W;%boUoC%A<9$IMQf4punv}Dg*tK~Y(5sqMv31^P
zPCdI>;i~cFPo0PE-EI?|dt7Y!J*6hu*O5YGm#m_Fweoy!dgi}(x82eg#og`(z3U&<
zYJ6?^GcxpfW=sAn55*fq_tg4!pV!hvY0So_G7__CK2<8xH*;w`voWtO{_Yu{Ev@(-
zF{(N3Vb$pT)W&<!HYWCGrG|)9f`sY^spfZ2MHlK-H)*(UFGyZ;kzMG2^w#t@eMuDE
zi3f=U=Uw}D{s@ZeEn7XO+THCYB&b01@Xe;2-#pb}xA-j6)t<xELwUY&rfRnyp6-;8
zU*Bo{@<;m=&3?DTUmVlIG`Q*t%zI@5DSx{vUjMp6!)3+fbCQZT-j&t0+EV29Nn3%c
z653l4*A8>ppKmL1XDPm*;7!ymN3HI7=+3YhPT9xax7&vha8#{m{YK%@)-x6}*9^pz
zACi4YSvnr7GONw?I7wbWQFc5jZ}lhz_qOL+CVT0LR?*Efd{?~ogb{NNYsL*Z$GFMT
z?{+lMUXOia<2xqvB3rywfxL+97JbZvyE%b%V<qgn3*8Qj9QB`Lu@Ui}x1(F!PVqWc
zDO3K;Mx=T5QY^=hX6i5p$BOo#C}#?q|MF8!qm1h{Y9yq|G8$+!K31lvhS6)eUI}s(
z6x_d)@2kvtPKsu(k6K-K4mY!9DcQ*Fly}N`zMC(xPq(A(oceL^(;6i7UAvn}zvQm(
zy(tvcH&#Ww)E$O~uFTWdEOlD{9+#44bntIz-8GtbqLrmX!Qy8hckrB;fuUp~q=$4G
zVh>KybC}s5|HQA&BeI}Sf17`#B<(nZrX6n~`LMXx!BJNmuKl)zL^q0;MSa)E*y3Au
z3$X&R@HvrdpHkO;r9PQn`LKnu26ecS$Ti{2d%@rRh4L3Ce(&%<9(9m|InsLI&?he5
zH+rymhc}KAEQAft`BsVe-nTHg`pKCs?OI4-;d)|%_tnJT(m4;<4XdIP$gdd^-$M{X
z=*oU}ws@A)R*NlUAI^vt825TNc!xH6dXny?=qaKy>KzS|dwgE+MuFY6Mw&2|U$-L6
zxM<ir54~Hb<%ycGdUWh#;kV0=EM&bRK2G=PUb?h}_QD57f_sKUBKfsahkMCzaDro4
zi#Y4&Pb{A6lF}YQ9$r-S7BdrVnq0A*r6HFBV+4cZghJ|54?M0H<%t?G6RQY%PJNYP
zpA>=I>E)2k;y-;s@87z~pY6paUHgA6fk*mQ?I&-l8m<hDEy#@@NkB&KtVG0Xduy7P
zS_<FtS28_H`YT)5|C2>+zw^z@ym2FWfpx9lt!F!el(`mUxM^;cm_EC2S4dHZhypY;
z3JMBP<8Z|uWoD-5H!wGM5>Heh!Z*(^CcN?~s$*nQD*9;|EicMH@WJe<`o^U|XPKmp
z2b8Haot>N4^lLP!$Vh=p<MkjkG}mAXB`EZYP?|V9JM++aqSObTj=ulaEr~{Fgq6VK
z3z}-u^)KR4AUT<I^+XSjD4UKLd?*zPwx_*xkNU~U(U|ZsxP-g3k81`?+=>|1K2vp)
zAsmWCsF%r72<${jHsYEhA|gf`BT@7t2U6d_fIV=~cf&DI8!BQw-ct<WM6cDcW5<YT
z5~89-g@rrYfPCKQ2#oh&m7Uk14G-|>*MBPMJW?M*+ic^4PT<B3Dz-7=*?mwE;ZjhH
z>gRnOjogpRhtv)do$PG&ysvj_a9By^yXSZxnAk8qbfZJ&ARXXQU0q%1gl$&N;2q+>
z5x@Yq`E7%*U%yf-dI;|H%OC=A^Vit>Zq;3$&KjLIu}CBA71(q2_U(jMeBsJOO*>?u
zMAI74`E+nG7T=!FEk>_LN=l!<w<e((ZUs&n2YY)~BI=@`;BO`<!4Td-WJxL<RT&@p
zB-m*ivgVT%AKPz&7MTc^OxwvPHrqftI0*Q@&iNbsdI<mo?2lu~e9us?zbR&G9iOA*
zb7nT4koPr|(At^3aoP0jF%MfBx!7jZl%7S|<nK)a@h7~PkTo$dz(;d;w*$5Nb%q_4
zJX8X-4abFy@>f24Q+fE}do1pdP_?oL3dU3<sNMK^lk6nX@_6Q&e@(z(R98%JqK@G_
zD-jngkKBEX{w~YRhMI*xfhxqLCF9kP|LE*Rxp#_mr}`y|$P_My6z?jc*5bNTO1y0r
zW_$d1-*T=9KRa%#n20ZsJTIVnLpHoMLohwPYt%8KET}3*;9J{_A)!8vyVq)srOKks
zM@lDJq&&v}aN(V2Q+iq7hPr?71(uMl+HulbSJ52JT6(kfP=gCeUTWzvqi+~l4Edc2
zg>{!r&627-YAyV#ydH{C%eRnK@1C$tY3ce+?w58jF1I8hv_4Aza8bgMb<c>g2RI?0
zt8&Fc1x*u@rjt2y^+fcl#_U2>jW4ZHz(vm0s=_W8({~itSEdtxcZ40~ntOdVgkXg@
z3d(bc3FL|`{=u=RXhX>{l+tX*-9vBGW#OPWr&t;lN7XecmODuL)vu<3s-65^^<~>#
z^Ea!0%H0-S?fKNhHhiCzgk(fLw)y8GFq+85qJLi-==U2|*yP$%8OfyUk#3MG+{isH
z5=?V~^>aaeE}bc}{n05hKl}E|v!Y*<+j!V})l7Z4L=$lIi86!(rOZ$|C_qUt(a-l;
zYr7Xm<tRpz!%D4D-ka^f7H56eY5hRMoNW2K^0f>R+<s1*S~V^_i?IO9U{Y>z&pE%o
zCQhe6KhmEps3>w$J^B5u)svr+4hSThKKfPsYNYXBl;yKIxdDeM2IDmQM0r<i*LA~9
z<2kM4Pg=*tygx)6wJ)v@MLf877{%zZksFfOPQbc~x6zL%-}2yKT0X*`lWilCpuxpa
z%U5qo5c*s9=6<1@NR`R2xtR0Zok3!Y2S;Dggh+fm9p+i|nY`$H*K3_j4NjU(<=*!r
zF?;9B4+%HbhVF;bh&r@EkGGqil>VQ(OuRk){61!T|9iUwr%$BuQ8~nEzDy`N)DW)K
z_h|0Zg|_*Bajx%fitkerbmI;(4IwC!PKcNA7pPd5D_8tpi%_RJz$&<d<c!QHA6<fN
zAi?g0qh#HaQneqQv<#bf-japf3!*kMYMbBv$l}H!`M}V9eSP_{mvs#_><;1U6=RhW
zT{A_eIOu7)pS6gUIezdWJ|8l4T<x#;Jo7ndgXUEps-;_8h}y-Qf8=yM&#}(}`QPtF
z-1v2sKO<ZCxBr_J@m8n$H)IZO4Uzj_oW5E-!&}Yt#EhoL$W(NNoa+Ru=vHu8T}iKL
z=2&x@Qii*02lM))0tIs4w8%OhkJ=E*&7!&r+!7{5!FY<d6zj8eBG=y^n|!{vJd|`+
zI9e<0&%L8NFRVyi-Sqv?TlYA0*v@w(vCzICfa1ryUAN~t2-c3q7Q(agAEK*=Et4x1
zLJgFbD>L+|Uy}*M*oYi;oPOABvo<?g&Dbc+GHERP=46pj)yv-CV0oHm^{H##M|-E#
z1oyprKteJdxLe&u=diEPu*9){qbzp_FW%GcrxxOoOT7MrySRRGpLp2WUtUKNmLI#?
z9GNT}3$xkJ<<44ceRF4rc)<M|mGcUP4*aQyNOdpGM0pdWG{_FMt~Y;kW-o8rHsZE)
zd~p6wrXKl}MY)-#?=MwOnuyV+&=4|yt8VlXHs@Troc&lApDZ8s9we|U5ZKCj*AyT>
z>Q~ONU*PQ4_;}f~l)jjmjK5y%V-07v4JrN1@v&?^E?WQRUeQD5yAM5Xa^3GcX5edj
zmUENuund)BX-fE+H+R(1A2g1p(O)T%W~8)DC&O?2UoHS`%5yzlj%YIKql}G8FD`6G
zk4j=)tu$!KHJd+hq7|m@EIn@WAtdb?&6lcxfW%kqi_u0Y`5h_0$SuB~ecunqigeP4
z?G~Ft4_VEs<K49^AvN#6Mgcu(<}8=ZDQhYdN!UNv;>_6SyvAQ#K>HBxzX1(y&S%pP
z#LLchF-iI#e?0wQ$hxqh)Gkp<OL5a)m)5VDuJ)%{z1#k!QC8FB!4R(ZrH=$y?i*Rn
zA4%4H`O`(pV1Mu17ka#^B4i<iRBfJ^<}{OBlrTD(bbenZT?>rDMkRB^i%lHG7#gyU
z$Ei7pJ;AQp>T#un!LR;6x;Bsf(MD&+XsfXpl?~b=+6&f3yP}<RGwHUPIP+QG2XAVv
zyyxO`(eOS%;8ji6$vND7VnSn?;5%%3N6TL*q_-7+=Q`gawfT`!Y<Mo88&xg_pA(5>
z%6R_#d1Yl~em(*bmseNoC^VlUq)G^myVlm}XX@}GgWNFWp)<_81nQ*SIS(W&MAOJI
zwcX&$dk4Ev{=0YkR~csFjaviG9+c16T`0<E@86L2>%%DD$7ek{9fW#wj|h+Flbz}(
zoq1?Egr12!l#^r1JZn??C|sjljLyI?@gE!e+MVGGEK?yGTzB>1*3!<@>$KMsj92HR
z$u;1MZ`tKfBAD4}FBt)Rypg5*N(q4-f$K&Zuez^DYvb)+7D*tm`^(c*A9GHLd3w0M
z_wM&M^&gd5W$QoQi#xETLU(8@IQ^i3c!I_rbsiTjXSb#&vPKLs1B7MzDvx`L{)s$s
zYL-Q`<qc~bkF<Mv?rA-6BBz{r|0Hsv#fU#co2RLv>rxZZ$mhH10d|8o4lpBRGfA59
z8eDLn!E{vMf1{=HReJhyDl%fQb|06&In1%0FU~>7ZPNk}_(NkO6J;a*W7*S(J$hnp
z?pC?kn#gOja(F%7wNaa7>H#8@O8VrpG$`vbrh?<`*s+#5%kx~iZf<`}ohlDSHZB~D
zVKfE_qIcUOGGIt*^Oc#E_8o0fDx+!dy{WH{BoVx3A14GYFH1=4QLqRkXvB~_xt8*+
z)u!eEt;**Wfvrsu_DOfei^84Ds3QWZ9r71hS9s&pl%~auIFHlpv-)u%Q?I~ie+zYj
zMvy!#E7QXD87J_(`_;$u#<vutlg|aWbSSgZ1PZ2>O_+vNzjxLnT<E-Y-zcT&+}}&1
zCZplKS%HZG6P*3D=dWo>S|7N6AgAnxQvL^aPd?^I(aDeV5xs^-A{(9IL%l<_=vhe<
z0=|pGv(nef3c`Hj>~5rIUemqE7KoGW`*p3CU8YB_`ymzT-Qq_+NCn^;c7oGqSP~qE
zLt=GMOG^ucQB~ANA_+vhJG@!9<qI`mB1NtI*lRMB$R{5&@%T3cevXOKUff776}i(Z
z{ao0ncqx=;UxwEFO`eXCpq25c7nV~yMZZUO-tgYl8zgMW9{c{YR<o0#?KN9d3YVAh
zWSpNw807=QHF)D57^Trc-JQZ(CBI4SwWr_|#eHGR%5;P5klQF=h9i5&&gzjZ6k7hd
zJ4d1Fr9AQ|*p}Uv_d~$FIiU;w^-e0+OnMgydzGT|=5tfd+Y?lTccc)yg;^H5KNlIR
z>K!$>z-d9TL3)V%p7M*@h_3*Z7d!xnp}I(HLtRY9hVD*`0TESrK(Ij}2i&O5M#Qrc
zzQ}Amz;ml`u(W;pG?KCkvc|ol^6gs_u2^to6=ttXOT{53T3Uwy1cnc+LgYq)B|yyr
zvj-++fKdt;dQ(|>@nsjX&93U6ewmeZ#n+d)%nr9&T|E?AqYCH0fB%p*_UEg4wex5Y
zMjViVdrOkNy|^*7EvGnvFeBh;FT0R&gQf&v_oGMj2^t0$FFKYD;F?Pf6e1frUa5RS
zx*g057caIsKW!X6%D_N=zmANpwum(lp>@X?81Rf68>g^r!sUjrT3obCIW9V1@$zq|
z;iwd$i}}x|#TJNMI79#gJZt%hUIFELZ-f!#Cb7-muCHR(>S@cvvVmOc{P}Q$Y?vRB
zusi$vH>w{5P~xqFBEV(7Ns&Vk#K6o7komGfPYUjhN6j|Kjrt9z>Og-#eid%g!l`Nm
z<j=iZiWr)cN2u}Nzi;0t2@L4Nt5Woz<KQ1m`!Ov)kvuG(*oJltd@i&ptrP-{17AQO
z=<BC<UqSd*eLd-;Y25RJ_lQnWjFDiZ#3wfV04~njSaET2kWo02Kr6dSSC*CrC6#Z=
zq<2lifG>6OWJg~gB4r1?m)ibGTX56t6A2Hx-E6JYFg6iHc(K>SLilK!{W%e9OPZ%s
z=W-Y{a$<sOK8|P5nF&gp7JG@OKORb^sHZv07;Q>c$KK7xuv?vl=5P2#Yff90be-V`
z7OMWa#=V+nTMdnrE!LHG=H{Q<pLj*3hF1JK^#)a`ZRZExZ#$ZpI9VJns01<?=xs*2
zuGVm~mwdR-emVGq6<2!9`kmrabXO&H?g&4px!Ba?bFH|}Z{hZf&R2>lH8Xjg_OPZ%
zMPMDnUE{G}D7~eXqK(W5Ur*1!a9w~%f%t1wk}~ovL%4E^_PaklrnW`vYYU_Fp+CW8
z0B8oS0Hzh}z-DKpuPanl;IrTx>9ofV${ye1tW69}?da&Roe_hZuUGShPA1|%z{ewA
z)2iTca7UR*?x|C!aMbx$o9BInp9;au2H8>(K--yL{{Yi{^3<u4d*rsF{Wy8CgKG)K
zBU=EmR%jP_28<zy#D-#So{WsvSFgYn)(?Ij85w~B>%Tl{tQBIe8%WBfsepEbB&d4l
z;FH$kq`_Z=ehH`e)MKnM$n-$ofDt`x?!AEgh<&r%Ad)0c&O-l24C_N^F|>a8OLlg@
zAcn>AMZbFedX?uN-dSI?{ze7x#lQj1Ki6U4)7bYq3o<$zn=$ZFYp3S{2jKTlxW0w`
z6?qNFCiK1Q<dF#Sj{YpXG|)xXbD8MsisH;JEd@+5G&m?HFV7O%fY9OXG+YP13C}o@
ziOb4@71YsDU?546EVKJJC`Py)`Mo>0&hOBwu6^tuDQxBc)^k>+bBWT0Tl4hJ3o38A
zq9U7ZM2KD7KArteX>7aa%hrCls*d}Ov-s{9=PQg3GIJcfDb`^;deZ)wRC+KOS~o%`
z&Yzrwc^RgG>|p5&Jajg@&rXkXh+mnO<QQkXR>B_phYsPSmc_@zydLOe*0cO{DaV3h
z`KeXAJsQ(`&YPXaO>--Tkh8o<QcRnW7nV?VF!xW0f6}{mDwh1y_Q%hAe=EMkX{W~<
zm&W8OeNmRV@sW7CP6$(9@i98DF6iH2UT2RsGBJU~-~x=n<xL9<3r75<Z{AG6Y9;vf
z<3}}^MxQ<Fu@`GS504~s<jc2j8Q6fH<84xAe`M;{)P?LqE&cDtM&0lY-ni7mC1c6)
zqmrQw@14y~9vNHh#YXl{FUl6QxR1~GsXzEsP|~<O!Yzhzv}^z>IXHq);K(5jeg^4e
zNTF`9f;Smkgj%{zzMx5NkBx|>|7GHspE^_;3%!xQ1`G@hA)bbx--usaQj#aO88+B?
zW56%o2$lY2YGi~QN~24N9~@2=)JVtIRa%e_ymaqV230xl%P!TNyCH;~iJU-I{`vZq
z+78W&=jP=6SdDA>`TlL})0UquNNT_fMU~T|AF6!3ywmO*xEK8NiBF$$wyf+MJh2(;
z1ed&DHeb%2N#}D^Iu_g+og`kZN-FdXw5zpjmlkhHKZ)!;^qH>w7XMaegY{#AVu?HZ
zehNpK;oY%{=$Ah;OH2>2I|LMLzBl0OzZO&%6MW%*y}YIKnbh~H`)NxbM0@ZrMz3{F
ztoy8mpGiBG)JuD;&OwNoDdJ4dPtHeAj}%X=QoJS;x9`+E>rLe%81s4OoYM4j!kN+U
z&Y{tH`TkVNbbj|D@1!3p&q93hwfVYgQa#>7&ZlVZCa9&S?hVoAA*9YxE2850Dj26m
zZ5-zJWpQo`8US70F6{aap`jKd!nJY+c$mLkxl+<Ux)5yFRkIC2Iv#Tgaq%ihMJVrE
zyShHSV0}A>m5nCkM`eDu_87lfx(mqRYuwTJskcxh!lPEDSv}OAr|#xfQa4;vc1)`%
z{eXIchH|b!ENhkq7eZU}ch;0}T#VmJHnyfL!V-&YgoqoTGBi<MUS2nEkAZSEG&2jM
zVqj*5iTUHtENB5{cF02F1JSL4(pq+;-{$Dr07SLJ+27~Ii7BRrhSp`0|B7PixHLDf
zai{yOb;^(rp77R}EOz!g*xM=-zReM(*>>Rb6?uxBYsUKtpM`^2{5yqh_Giqbn<oAf
z^!P1c&!iBa>XC4b_WDwKv3(w2(sRaSy-dB&!|T1VN}7Symu;w|_*Vj`|I|1$I?Ke+
zcJ8xQ9p63jlEZI(pW<X@Q@v_@%i>^hM*S`lxx63euAOCnCg-vvgb<)Pt?A{EkSQJf
zWcf`0gIC2WoB^W+@VTSNY8=H5^!$0v)So@XV9ubkZ!n1BwHtdhf+p*W@5~(U6)e1$
z`4xtIyzq_1#mh5gLtOM+AB<A<c%3CF|Nd|lzgvqjAZO_I`{<`-hVVa+JW56ibHYQl
zpD??^Z<ik%N)@iWq^}TNS(tR3KD2YsA$AeSK!NAtl)lNBAqWxltDKzrL9uWAz4>as
zsVbZ?Xazd$^Bwo|B?=_!=Toa=@=lT_%_}uq>mMOpt%4BvyhfUyi@r|gG72!bOA)4s
zqYGQR#|F~9m`wZ~Jrbe)hYu75(N6z62HBM!3#m=&`~#{IZZBQRd5a_I6S<v^*m}zJ
z+h340s`1^fAX73h7}V1|QMEB$eoX0R-V+a>vYS-3)-ii(rFN_EOEG^B*&Aik&-r%m
zRjx&9KHkOX2^!^H)B=jX!rDqdn~Q&M=D*AFSY(&aNg;+JX-TFv)xEz$jJ}419&L|p
zWErJ<vw!`;77L41w8{@vZ*=(TeBZ*<(nXjfp@14y4kfT>>Se+EX)iWnN#msmDLY2j
zD3g_&K_`2@RmIffFp4J_LaT?gl)E7GLd{lrDN??)qy!zs^l&P^<SfaU=7=A>l-Fpe
z)G7e&aZXMcfg(DEGBOk=22F^?Pn;Tf3aXrM=R7Ct`!s?(!ONR}s>QY_+Wm$kBhGE*
z7t!{IYu`SMi#r~xI^F($k&lWDdakZEr0hcZyg+*a`uxxa`^3Hsq|&3#C_W*~NNJjD
z;5`qS_W4syL5BBU=0ebblzTwG;)!MMeb`tbma81p;5wW5q%c>L%|i!)Q?taW7;8z2
zd-)I1-|k%4E4NT^FvePeYjx&Hl6w*JFFT1tVI_wj(hZ22r@R!V4}M@pdA}}=q|q6M
zjkUcCWyOOJU|O|*=pEKzC8;1~;BRCX6{fo^yXzV|`yS^0(GR_44qXzoV}vL72<NDU
z*eVY@Z&OFIIS+TrZ`sElT5mGjBPEjXTcur`RhKoSgOm19vkQH%$k^(JR0Q^66LWKP
z<0yd>G_WOM<N%{x_}u{<;F@<_fmb6;7Mcdai%#I+Go(WrT3QlfV*B^+XT2h~4QEY(
zbtB4V9y$|aW45Z7a1Xrd{*BWO>FI@qBK_QlLI_aUczJr}r(dzRx5u#oaT=-$R8#=>
z5zGato>AMowUJPdUOYr#CfF3o8u_=sX#M*FDIH`k*T27w%Og*n);wEV1SxuA+X@1x
ztqMxsyio~qj2Ok`VdkD5FG6mhp&R}B6SM&e@#PSxt5L4y_h7Bunj7?)|Dk|19k>zD
zrr?1=U`*MjvKl81I>7e(HKqvgMK0$OBtrG0&iKr%n#4Kdvw^0r&JE2?PNI(Rcr?@_
z=;h+Fi2f3{MK`+}3<j@|(7DtL0|DG_l8hJ;gUB_;Mgc*=k@B*>*)Kc37>#f+k!4;C
z2;3BDqW?`erl-PleO6WI*0QG4<9AoI$a1c!FOV6G;c+e}@Wq}@*FoTE*w1@ill9De
z-h2zLC#7S_Rg=zm2N0&BzG!o{@7xMLPq)U={Ko%mXY)Bm-Fp<V->6(I`v=tNsW^Eb
z*tDlw$Eir})ZC%QNw+VXUE#vAn!;vev0GAUv9P<y7N@SK)D@8vF_hFVzAD!jC=^SD
z>m_)^yQi))gns}=v;AYQeD5a_lA4>uOS+VIc<RgDR&;i7{;cZ0MwCxa+b5ZVzH6Kd
zYE>T$<_})Kl6pk`;vElC@l}4&Qu$pRJ(tW@?<B|bRe!KquC=*1W@a=SW#lHCoJ?lV
zWfn5s<nebsgH@U);?a4+Q)-Fh1@h4+Z>A<UMG&ra*6O>q%84g-j`Mlbe|Sg8Ql4wk
zdi&vV-s2Mfb&6e7PA4u>n|O7Kixx(!DAT-b{|d?0iQ+Qkb*%WjcrAGGEx`}nD?aG&
zjd^Ye&(+a!ArTNGV}slgrF@MS3Ni6_wJJiAn~t}?khtAj@ejRm?o`jS6$e|2v39SU
z!hF0Z*Zov?h#U;&VfGZ^Vmhd~dAVLjnQu?wH|8Y8N0;26ObEp2_-k}<7>Kbyp3oy3
z%U=#uP!{d<U*FU|Y0|tfqrYj+8SqG{il6KAgJ(-kX&$Ur(a-E^THRZ}n$BU#qs+!b
zHrG-vd(NHx_TSfWhlvT+(n-t=4AS{me-sxNBXBWY2Z=nh-^zDg-Qj<GCn>#s&iU1G
z#-zIg4mW&H8kDj+OAqg^%;#Y;R@Ext5(&0v%DJdgy0d>mN$jXVN-(>nOCIgvW0gW%
zDx~xX+3(R9Yx4G2`f^0R?S7Nakay#24}K;o$pp&gVEL`xW0lnh_V4dVF{~M6XQb@9
zxk_nE(J_0{BC+VJ!o`^-R)mv_t}f(}+D=Y+PYOt%prdhNT0Cvl`o-Lq;iM0vbj{P|
zvF67)`9d*ILz^f)*%YPE?eej-QDXRO${us1t^Q!@$cE~Ap^mI!uu72l+ev#%wZk=i
z)hempp1y8XX8t53j5RxyY&h>7ZmCUDB3s=$DnaddFZHymhE?2wxV@cwH_i5K9=Y+?
zKFr;+=bY8&A<>U_n<PyxTo#oP<{t4I%l5A2wCNi(W4|})ZmpOTJpSTl7?65d>$*cE
z4h$W&36JOb&j*FQ8WDQg)@!}Sq9l9y7*~m+6n9m7=@!Q}!;zbG=AxZDgA2wM(qo>}
z(MDF$yrWTe>uly)Gq2SJNmdo$=weK|yZ6`5t3%(WnHX3lG`6Zv39((`3DU@X(WWwz
zP4ZKsX!DV1-t~`@t<z2BTxQ<{<3{VXsvNXCg4!j>-+S#Pp<I5WetCQE84Lf{iskpm
zujT%gd3Y*ftrJ7qjJNLPTsSMY_}!g-PnO+~X}#$k7CSEcJer4BM>3nl(@Ry0<wp8m
zM`_EEd2Eo>)Dlv(=fA$(iC^`WrbV$d>G!X%HyRj^{<1_Tii8InY1Zr?mb=f0xYK0T
zdVC~Ja+T@SB0S2cTUZb_kM^cjX^Lpr=1x2wS)kI%#mDs{%=l!qvDi&r7e)~K8cIsL
zjc@G3{Mp}ErWmGf>nF2xF_GWHRtZh3N)T^}$$7h!vBbj1YMrV@q#UUPt1wc#rF~Z@
zZC%)t4kbB-rXFGw$ZFc&%zVgxRVj9vw$JwPqFW5q>C%4=%Wr2{6e2ZkrNB-*1&%E}
z2y1IO4(_D*((Qh#=VngTb1rlj$}gz%c;W>zZA%NxZ^+0C?}*(MVAQnsYot;1a;T-%
zQ_s!FR{D`$KeL5>Z4Jly1Nz>(M6#tDPJVb0mFC&F9aZ8=I$DQp)x012bqgZB9Sp4b
zXD&LbTRUd`mHF2+JUV*nF#!J98<urV*Q*RTCV#Ap1Wz2RtrOX*y2dBH@3%m0X2fQX
zt&0{JBEO`L?r!I~?(t&VGQ-AJ{o<}v5MU&v^z%=DF^@}}%T~#_%edN5cy~o$QD14c
z^r-U9ljSs|x?1~q^V|OR7oOlYabAp6wmB{!yq;-Q_U%1>7#828Hl>Q;;HEO8G0FC1
zCy!o}@nwOgB(v9|bF^)X%yQMkRw4shXSNvy{6;98D0;*OL}XaA@RMgOQtU=qT1)9d
zER4d|o>Y{F3P{u6k09?qX<4>La>7Hk&qeRSwB|WWQPDp~ggwt}s#Or;gM|_~tX}NA
zNHl5OXg?iEXFO!c`R%@OykR{r#}TS<t!T&SQAS7E+bpLXE+~yWPdIgFQsqQ&(4GY%
zLwu*^<34^L&_(j~j}4AZx;~*avfVGQL4Hp92pLCgb8yZ3`>F9|XIaE3_i+V&V;d#)
zxlOQMm{Kp)@h39z#3`NS<27KKjI1xy8fEG|pf(DKQR$FU5o0`|%5t7y(fKzhO{o9m
z%L)3dNTJBbeZfyti*y5OJU^6M66rRJgB4^UH6xM{O%(kWcP}4Mz0+JKB|Ipm9Dr-o
zV;45+3$xsu{AU!)mZJB4Ag}6q&B(6-QvbMfO1uA?lGvNPGqkj=BjWuvLB;;8dW|%0
zir<|l-mNoGv~aLrC2dn&*732C8RUb^GspYs;qc>c#7{b~Ya8;gWOv*}4z)!QxMR%I
z(cnr*9xC_Zm5k8kjdLkyWS}MO5j|x^9bFr#)tE}o_w3rzScAZ6f@Wuc^2w}_3GURo
z`7+62+KAAP6}Lh{Zg8hYJ>6|COO_*W$MB*JP21Tb2naHVY~k3V3Atu>d<{SXddJRJ
zi2u*-4m*V9t8y!j_S|0udlvQs>yI{%UzQ}-d2IaJrf%2AK-P1;Y@*EO*GGOwsSUUE
zmYkl1<{Bzp*Y1hzxMmw9lX9bNpAb;t@&DznlXdCMjbRj6UiLdNMxo74e#6+~zz&lB
z+|U7pm0(mtyhJsD9hM7Z03~QB4&d(7%TpdH%st*(CceNi;^3yJE~b#jC@-a0dUnQ)
zjIQV{i)c{{wconud-;FR!NN?@mVN^k-`R7}mjZ}ujTB!Lj#C5wd{2>WE9>)G*5e<g
z8eCAtwAqSo6MzN*fY5%0_(jM$2vXjYO|mC<>?FxQfj*6S^m?<`3Hne4;&mu9P#g@D
zjCyLrL-kGNesQcoz&^#Jm{#!i$juwkag)!&t84=57WpVp)yFi$zZ#8jNg*&9?@sui
zl9IyA9Rm6O0|#>R^12GHkCdiE&yUbL-~RkqZmrKdLp{8x6@l;q6e~V*$gFN}?MKKL
zt`VRPC9umlkEw9(RL;43CyY6JZIpEMZU2{7)s{!MEFCHvf(8BxH5aiye&TPSXT$ok
z>|_SVxY=g6=KN7r59<i^f7eR?YK+NUlriCg^oAxO222DqTi~j+%UE#ZC`LZ2rPEBM
zpfddm2LMpWH}k*bR;BX3@<povbWH8Og5d*>;sbyRPBFBltH;A#t$*nfb7%umrT+*&
zbRNNFNuN+(13tqG!!$5ZE?p<Hq~ufxVG*KexPy?|549c?G|;ZV7lcuIWTaGz4B_Kn
zGIj0XFYsJ`)i??a9w;Q*(P@P4l$)X9=?z;24*JF7BnlB%H#gX5ksJ*J{xlX40_tGc
z^oEbaO`7TTR~UaTc?{pf`*4;1hiZHf;-}bVJS_2-JSPFGf<J%(Ht#D&tXP_U$9KQ2
zsE~@l)U-F!3m)%EN)8cwL)Jhwb#?iL5UsF?h>R{||I8lrTdQ-gI876RVIoBL3A9gu
z&WV@owF0E8(oC>%FKTgsrBEHQ{O!08{e0u7l-utwFtPM@bg;&$0o#}xs?O`0{DhEw
z%pJkN32<?FJ4o*Q0*aW@Hh+6t804Gy1{bnCd*2_FTAPV)WNA+<EWgqIT|PMOz_S<e
zYUvXXr!+ol*Akw4@8cOHUtT`L<tS}kk!p8>JS*E<-<&-fni9~8cMFS7?;nt_FcXBa
zXLBLa4^)bbj0`+jMR6ElLhKxV|Hfxs9YGbNmQLgjaGI7?{mI3wEBLYgA@CY`M}6*S
zi!nd<9mcFdpAP{!dXY&dtt4sSbFiSY(9zSw#<h?*v}r5G;Pa>35Sn+0<zt%1`um@J
zzn%wII^_OHDs!3`aH{?X3A^`{>CpSa{cNsS0bmd=!HL9385;xi6?iWahP7xy>Kj52
zhlnnGPFF{C8qrz;4;5y7#K*@kbfeS0SnYe7KJ+4{j6mJ?=@U6~-;DdqE)4w>mzOt(
z&1U}|U`gl)5U?;Z!mc=haV$XBiJ9m5%s(Y5C0wknUvy1+V+=$5qeql1a%Se{^0Kmw
zk&Uq5%ts>w5mJw`>VJ-i>oUk54&Os!f0)!_=3DJ8mA5;{Y^g<3ceGH5+!7l2{3)Qo
zctGp@3Hyg1Z7;M`d|>Y*Op;pkr52Ul{*Bg8n`g|u0>CsF4Tl1w{P(?7p$#xrz|b^@
zY%N4d!B_+iB$O;in`e2pVs0e)j!@+?J`Hx^y*io2uV2ps=ULf6IN_P@LF91!PYX~D
z_A4U;v5LR{`~`(`728%3+i#?iVF*tj7$Kks_h!z(jt+|9ELq$`MASVQD04zMGrV2k
zsLbA!mm?lxkD(og8@_%`Nx{Dr-8H$qxLDYI1>-`IumEle9WVePo)ae!*QrDXBM|YP
zL$<fmAD4~rNNfK%4Xz>2DFL&4@Nxk3Kxh7qVXYsFzRi|TKp-h0!M}`#WO~mcv(KN_
zFULrBPBllV>QN-Ud72#TAM%pg?2Fb7S^96Enk1`E^P4{H(JUtEjPG+19#gl#uSY&2
zEEG#?co!Vz7W*y%If8PXz=?f3UB_5g_ip%EMESwf7gnRF<v88CUjf}|Y_p(wl}0J}
z0K8+(mr7sa$S&o@S6@iip)S(JZ1iog=Wprj_hcAk<50kB;T%ntkcZ97E`%H!8yJi)
zcmO-W=T>Zz+i7oRW(MF-Bq8j}=_C7T4#SMdxvH5Cd072`7t#`LNO}V)z`g(mLXwfv
zLt+OBzbrZG60PUA1QpabecJ;?LwQa*SEpFa9~G#c_>n7{QI&S^lS=ERpkyuv6^ajF
zrpx@q^%4^zvf$<A{6ttsd0vpfPW|-w!ED-G1FS>jer)|Q-#)|!efQ03O<BHQ;CzV$
zyS0NurXH{Uf2x5^R;eHo*n<!{!ag}+f;KI={r)}5L1xPPNLfI)7OO5Qodn`WGrJqX
z5x~F281S&c(dd7ML@OLx45QNDe>~aK9$)RcQqo$&7RdGA3){OJY&gig_q%h8mPGbf
zXY{E1r%(0HjKwDdj04-xT-^7eG?djy^3TKbK1y18X%zD<bKed!NC%x(V)OWCDyI%e
z1G_NJ3t}L|BvMlhc<9h)A|8%64v(i5?cv;AC@_>?oZ#hksrU|_5{*4?9P$Y=-@E}C
z))+!SMl!}rp5Of)zW}Tm-UQeioy?CdEzoNIH^1_wW)d%$G68`GQAWfK;IK8wKCTx0
zxE^V{mX;~Ot%U<K|D$@Kwks&0c0%L^C|Fptu9Q4^y8G~JY;ZX_AXPCJh(}Zb{lw=<
zoG_=vMIcT9y2ogsm1TSK2*&XI4<=tfXJlrUlb46C29c~bltupy^5BgFc012RQX@!h
z<hA^xW~<C%A4586*YjUiRUb2)7Wq605nNVBTE;)o=IPDS(k|*WVhR_dN#L^}Bg84f
zN@!l;?g(}e;Rvu}CO>|R01ggm3s5Aw$$#l0$o-buBw(H$@)!-*=5d|rFUc)mIti}r
zu%MX-V!x^IVgA5QX(^pVj0u5D3ZQFj^H`!&RfzRtoN&;zPTu*8jB?ypfGOOu%@~W|
z_sRXie^X~Ya2jESfS`Fg%ND0bw2%SOB^GQ%D&;(8c9Bz12wi;38K*Y7um-NU*)U)=
zAkdO65Q0@o3vT_XiHWuO`|?klZ2-qOThK!&?17^0oZKR2lpyHE8xd`RQ4Lm7p36K{
zcMx<|6S|M&nM~OE)7A68=5}oy-1n?5+4{*I8qSBKF2Z|nxK9MBGL}AnG;tBj@c6Uq
z4<g%a>vVodiHGX({`-cy1oI`dImLYMW4h_=^z<eiptaYw$GGK@JF+&>$>9NS!<|CX
zV^Q{>WK%osOHUeOFeXw|6`utCiplVAUM0v35%%25*O6-vV~`@xtK9NH2JYs~1AFC9
z@51Ur)!Q}s<w^<G6~T;I%BB8#+1|UgIIv4h{&_2LlaSbdJw}A@eRX-8Y(%7|cbxgb
zPFP=}N!=wnWux1DxcO85R|oK**RMZIP96#w3J5^KjtO9>@G`m_Ku8q|H2qwJJsIYd
z>LEW&>Jo{D)#1#136ANq@?Oz@YKGa}4B>k;)PAtH-VL2U)5l$Os>z+kbwT2p>}?mJ
zw`Ax;Rs=CQnm#l-tSeF90fHy3`bRB4O{@0YpbiL~ztdk(|6(-74|3D#i(@Y9?#0x1
zYLv(ruHIkl{Hf!ka)sDPAr7kawc<+n=l+MB{Sm%9XNdh6zIaCP3^9@bZ6Uu!B-x3M
zOT_=av+`3%>f{IfLShHT6?4wN#PW#?@&6%~!AQrRsPe>X+52MP4;}<B;Kh{2|3Zc*
zzrHK(zqX6y`M)W~F*~RB#NDBq2M_N1=>Kk01YyBpiYZM6-WM-^$3ah}hy)`%)%_)Z
zFvUV~HniLThnl$fY@8{cLzGTMNgRwa?ihNl_-n`xDL^PVle{#Z)t>F|>vIrK95&dw
zOs15WC!YO!k?QVlhO6z)Sl!r&4umGOjWd}rq!t%HT>c7cC_II817^6*`}fr5$uhTp
z{7CNF;!XWoV%2<hs`{Iq)7H%0Z<Nd}_x9RVRah3(E*ZXfqPDg2voKOX|6TOPBo4c}
z;ogw4`iNP@QCI1^wXCuVBp=N+9=gf|iJ1JXJ>C06dc5d`OOM4#s8C~KVh*TdEb-WN
z(|)~NBpNj};u`MW$a55j;+kfY_sD+C)bn60RaLxhB2mg7SX_I*@%73>O}{^PB!UNJ
zj6@eVOb1V=W?Pr8J<v=)ZoI_B6|4HPtNg4}2vh&P?uRY#b6s1FWLRg?C5e7S7@&+8
zDa}t~b*B7$N%2jnm(>YkZZeK{TnP9<+1Chw#@P)$z{pNe@o*_4g&X3=_t)QmRD;3{
z^&oV@Aq0$~!eBq_ije)IcVdsmST<0$AbU_3Ak}~&{8MWy@>Tfx!SUkk9Gdf6o44eo
zk@8x}F%zuD^g&jtH*i^^Wk8NIs1F!hQO%uVIDhg8BNNks`*kSiF$^h18(Tfxqps3z
zD;FbV{I)hR=`2x&lS&bX1~z|)<co7s+L4QXNn2an)D-_T?*`}X4`mO`l$aq-8-s=)
zl?PiP61TE2WjwaIcV?xbK`F2UL;&bPq|4%&9-71UiizZFX85~0nXV2FA?06iCm?eV
z)W#-{T;XOLfa~P<;5Z(Eu*J5>I7M4SLjxZoS{6(W^N@v(z#M^{@RSBdUCMKEbkxu8
zM$UJFhNmp^%Py263=9l822)sdU%otS|5dk&5zO;Y3_-{Z!$5K+-b0Eu#zu~YLNb9`
z{2Uo3cm2<NS}S9!ua8V_C}}|HVOkr49FV^HNQE=F05_kQ@P7F4|8z5$W%$kMI88H%
zgZc9qu_y^vAH_Gu{3*YXf^bJ>?%iD~D1h)eY3zdB4kYOnF^2!b6wr_3^M%+zd<%Uj
zQmgZFbN4;T`KB*_m`B#&&%9QV+eUF<k;JxpQ%69WNXz?M{1HwZfg&o>9>dC0xf0_h
zz7j?r#Wg-9*O%ov0(<!5A7#lUjJRe6zwn%{Zld+|j(YQ6)_d#zfwR??CY2#&va_2v
zEA46wz2!1WCwE$xa8wI5r%@?J^qa3FYGp_zS<Yy7zmPvmb|CrRGv`00WotQ(v&jY@
z<ujH}zdE{IO|7V)+vvUIbeU7+_O%lCF?mdyuf5rK%<r!Hy^k5&Prlf{`*roFuDQ6!
z-*{d>_wwnNR39f!uVyj-OCU{;ed;^WP)4QrF}Ud8_|%-KeU^NM&dOW%QnNS9kFv*$
zlIE(y$~M|wGVA}-dZ=ppYb&#UK_IZhb%5n|PCT{ZQd{*2^`N&yx2f62grtSN)($>M
z+BOi`K5+YKB{eoHj2wE4arbIO5(zUIVR1yK7iO$JFMJ`p8*2<}7c-QH>+S<+x~)#O
z;{G>WSWeCt3JlM~<Bxka1Q(-5URqmP*3P*9>RoUz@7?*b>r;cpOz`f|XctqNA-N*)
zpVX7O^`VYM^zgGFSPdgLb8<A&#{P3_SGY~}AbSD2{5IR{SFesh_cb+z_<9t1Z;16!
z`>%@IOBs-IL1xKA_xASEI7$!HX0f$GbQro_jrlM<bi`1obRD=>@Vuk0CVU>Ixa#E8
zSb@24!_>DN9dpZwFT-@5eGJ>EEBgBx_Dw*Wh^gKzM?B>{+}{;ot^Q973MF24HbsR3
zwh+yih)ZW-W`3QU3si+bW}MrDJ!tPiX0+9)0I?*aX%U2k^!yWa51_Z0-XZHc(E*JL
zqTfUkY|OIZ*9Q&)F6%86LB6_ZrobcL8ob>&w;F2&ZJhFp1sH+Qu+-P{M5`b>0m#N6
z62gA|ybLD24621Jy)1M;q9s5Ryyt)HxL`=e7TIVm#;{PPmJW;5$R#}0xRk>0#&>I<
zcTIxOLl!cEy)fh(W4Habw|tT`&oR{6h=7eStM>K5*yQC_4X)AE4QErFC)zxLqbBp(
z_gjvHf57ATc85N%J{o1PgBZ{B$Mdwa<p6Ptx-Z73s&FbwcgNDI+GO{{H+ofxe_t_o
zs~V0-%sV7los=stB<?NDp<6Qe&-LcEP<ghmp#ASNWUAUG)NWcO+o}sA+p|^fd$O}1
zYKRVPn(EV<U#VQm+#e$tzg;{bBRnIT?7;Z<U~ZZG(a#cl$-Sr)6|5^7S9F$s96tEx
zUqIQ|PB}wm_O5jnI+^M@f$|QQ)n8w8Sk%<t1b$n7GbNP8RrSSlBlbgy47=QUw_av_
zzaReLSuOfgqE)G}vsuYknb*>LWRlf*Lm#!sM^KH#)LI*Qnapl(?)`X`H_5H~i`ZJj
z_?A#kVn4O#b|n*!Y>({xz5dRjTixD!oHCECYwcEdGL+ja!cXPDRV33tzqML-Yx|-J
zFU#rm>Wuy^N&9Q<w(DrGh<5m?DQj2N(ndI^t^!xVlqE*WTW)R(Lo}O%pWX>8rcf18
z+-yC-qEpo@W!gA!nxnI44}X-JDV4ryskLgE_0>L!-&f8~#=a2mr!(!c9LTg)RSo$%
zh5iw<&@u5c{qwiG$FPrMawQOp<%#G9t6IYVzqAjd3#flH^`w!#AK8d;)p2S+V{hGJ
zjRGi`iOlLOliW}4-ca~y^B@=twI6$Q%|F;^7CgTFTDm;&b<)+UEd^As$;{%S$iLhl
zeY7F<2>65A3azBMId`E0631ymu*u^@;_t`lfZPj+oJe<GFB`BbkUg4v_%NC?9y%9E
zMoG=mv@{#EEno(tRlsUHP5XrqpfG*hh(7*5T7US@AGeC{nkHOvYEq051omN9X^5(P
zXYqTXqT{EBsuc49-p~V0!Ij-soA<0_2oD;4gEQ?6D;4=Y4X#*|TpTJGv^9_f9Temn
zs6xJC9Kv-UpQNgMj26`6#Xbhk@9$sfo66G%F})t#wUGsN=!vSUYicUHASeK2gQpNB
zzP!AaRrtaOoQ$VWw*_)~g|^Eu__c|zmXr=A3p#t7KA{gCTcWGBH(ujX3|4=An7{I8
zi7fSj&o)ML73ObT&p*)d2<1OC>$!Ti|BtFFSNfmG52xl@7?iyK^ma2_Re8GH?U_~S
z5;o?|q10^9KTgJ0xvk(e*J#sB6~8~L$Ie>oUi2r4oM6Edbrgkqf$Dp7pAMS4>M%Y2
zvVM+A(e~G>PlKImq{XLnljM->7AnPqnm&z#%ZaMx)T*2h)}EA&>2!{){@hp18O!Th
zJt<HgmAm`>U*%jUy+g(iRigS9{CoMQroTR<emN-dG@5rrEmTF6*QzBh*00ld$?g1n
zXPvcQVsz8mWkBV~Y&fzXJN@K?fXI+bdA}qvihhq1=0S%oQ%}zXIEAf#f1%j;?aNu-
z&kHN{YrFe-=ANbJW-<v18P<I3G`l{3oyxB7b!@ed?jgF(N9N`kMuLLx9mP$6iDG&>
zVmgZwybH0=nkz);$SqeHOW964*QRx4eu-rRSRc*%@Zm!}ef`Nlp16hve^%Z&@=!KU
zVxEtx>OS#=*0#13eoI;aZw64{hhl-<6W*YB#<W4}5I0|cVo9t=4!W+`D`HQOzcG9}
zlq>}r|8X)1WkU7Rbuh14RX56(I)se=nvKf=PI>~gQRnJ*qmF2FeyNqrHPHOH-k!-y
zhnJsU>^~7V`Mvko#H~-9aIpis<)D$Sqx$;3SqkP%L-K%Y!cZUJ1CtSBe>~BlLJ6+N
zi%GB$D&vuZxbi~y&>d*X($WH#HC*U@n^!k9>e<dW&|j^NdN|qonng|9B&{~~qoUwK
z+O8Y>%zHaDo}Bx2%#wT{(N|R4l|3t$Kz2yVkJXp&awd0~PQYiQ8}*0A*E5F5=v|M;
zDM4VqaZZaoZG`M{{z2*#4P|z9p3okOioZgum41HR2A97GSk#iYHGE0Ga6Vo9B(q2{
zK}<g@iiz!^HeJr6%HLTV4ct3<o}MD-ZJxZ`%<Xgb*?gxtH4D#2o6m&@>Ipj6Zy0*J
zq>qexwv&7$D_)1vj-MVKA;1vG9gD*a=7l@|GZKFDd@CxSsrP8`lb<yeX=HikeZ92N
z9bR983XRXl91eN!c&-Q9z^V`Z6{?J+C3@oiab8RkdKWi$9=lR_9?vgyk~sfE)?U4O
zg}DS^!(LM|n<sQ37k*JxGZ$mF9ZWK8>TE=S41TZnV>$K!*g#QtD7`e{VuD7-@bIt-
zC;PL8ni+S~|3)^C8#<I0Ar$hnl*4(*is!e-k`dn!&|DwVU<IH)<N|>=ec<G(h6_AA
zkNcXI1Msh9`<YE>LI~1HT(x$`s_5Qbf&>~10D601K2XS~Xp>bqxs(?zpXxX~y0i|}
z4FYfhOH^JGI$D|E29eCLE_Oy}fzi?O@HIm!-iR__wwgz*ws~bRa=rCsJn!I*o^7>-
z_htMPL*qJZ!(Yu>W5<@Yjt7K<-X1I)eko7&l~Jq|ho8w`IS%!przO=#^y8gY6ifxS
zUvb7xzgs9I1TZtL7pkb<{$_1f*)6%uA|ab0JA7V!Y;fdeMt34}OT(W4P5s`8be;9l
z>f*M4qaTF+5?C8fJI`@FG*wlm>ehRkB{x&_PCI{7^XB%i?%~_flOCwW(AekZ9%!U~
zAj^eF4GeWay6Xj%u^x&Q_t@t8cfu2c>>jOV%sNefJS^Ju0#+y$4zqcFQ2#kE6fhVQ
ze(`h8$l<zIeAJPazTX36gjv$ipla@g&*<98BlCIC+}%HC%s8##`!>3DCul4@vup8Y
z_+P;%yAJje$q`pVz^fbH5~GVt>)rs40iK2EpW%WC=u#dIPwUXorvGc~Ed!$bzNk?|
zVkkixX%Oj73DJ@6?ouSB1(X&Tx}`zs?i@-<0qK^MlrHIpdxqcpe?Q#&<<1w!!^6Xq
z=j^@L+H2`nNGs>6aX+B;v*;#%La_u;?wqkrkP?lI{qtd?0X6>$F>{bV6%~bErxCl+
z1FySf9hbQmeoJqK@Z@0e@kDGA8~!E_k?hD~dn6uJH8#pQGw$ipNdwzEkWzx19U}vS
z(gr}^@I9$S7f2M@KKS%2AU-iMmKLuLbX0<Nk(ynu*d7%BHo&}^gM-otST}^YbaVDV
z-R)TLpl$ylk9%#M)rL49&b1s=v&uj=pGam*eI8S*j8pR#Tj1}f(!|g?dvlRR_gDEW
ze5~?;YCI8>o*eXE3n}>8Nmra_7yaZp5A+2=cCmtwf%*RZ>&C7czHJSI6>EE$1qvPt
zD5O(Ez~jh1<f}Z9?!PG`p0Ymz?t5i=#;QSUz^kQ9P+Q(uu{Q!jTfQ0)KdN2*O`e<-
zH(8Is$yBe%fWyOU#g~>S#JboqEce|L*f6xCybyW{9!*W<>yY3^V8mWu3`D8Ave?d(
zfCY2pii`{scf^=IhPVBC3-^X0c(0dUH|C$TaZnh2bR*y%kStCtT_qf735yp0<`DIy
zEclgD4yI>iXHuL~p-^lsTdJ=7uuUNRoAw&$syfyMo*V$x0OdHq(gq^A9SC(M`eYLj
z?}Ehj5s=RVz3o7{s8GZG`rI*I4kVDU{2bfh*<B6}ju);wNzlxS+1+z55)iO#g3!l!
z;c74j1mZPtxT~ux9SmfuVBf$r0SEv;i*;=JLx)U<2U!fUQTTw7Mkz7^;4pxWKr@E{
zBfDp4`5liNs11XTc@dGY&ThcsR(Q6(w+H;t4?cMU_r_E?02P419h5SqA<rouHKz}*
zI@QAAM$MkdkHjs&kpMm#5U>UeSEYP{yP3gvJRrLV>jC%xctb)0r1cuw+CX0kZTlBc
zXSyw6(rYQ2uwFLrbjO;F1rrIVf`eWOfDqkx;Y$@yyk&3)hOWs92}=3EUNZTe`G3@P
zV-SrUf~wNbBS-M;0b5X@L`d-+ps)?Vf6QY+OOm3W5c<RZQ{!&bWuNgR3M1~qg)`#q
zue;vc2q~wJWBztg#KD!Yt0GxO&6#+2d|r8{O?4Kh=wp_56P3u~o%e3Z*r_E6|LQKq
z>gILSs^7DJ!vbefgEK?Lllj$Cxz{HhEn<_`K2AL}BxflkcZwyEO98=oU*v&qrQmLm
zw=}<45FU^FUPAv}Uq`mFY9OV-oJH!@6R2g;O-qak+m6pp{Xr<tR@LC`O7<RSz8Oo{
zit+0_IF2><9Vf74*=ljtPJmE7IrkIh8{@jxZ_sGT$XEnb-l;>_da>Pk5<r?k{e+*7
z@7JnR-K-cei2BZe;vsU>1tcAhIj&9Z&ZGAlU<&$J&wL@J7G%a8Biko*f-i?*)tT*6
zP24)mCq!03?Bl{`As98U;Z02<-L1?L1Ho;k*WO+%pd9CK=-cr9<^YHxi1ZLw%3A}K
zAyC}f2uVl+g}LczT^R*T8}#&xerU(ti0c)OC1%a!=;pzKAx+vLm47F7%Ec-BD*_T9
zip0I>%h~8ZrUG+2yN@-JuaW(f#2h;l1~6o<aF$fxfW-|oP<R}lF<mY`b=_HvmU#+J
z>uKSG<aJ<sSTMQW>1B%)9T6nmTxIRS5b>@!w|omZdzj{mGxyw%%JyS*STtwqAu76J
z3p2)7MOus}N0vkM_=l1_cMnscrCQ)o1Ccby@pk;TWO7G=i^&h8^qzNMh6I_wh<dR;
zzzn6bK|~E;u_-Zg0TX*w;iHMpMq}6Co=QY%<(|jd!!$@0D^;{n9MBp;MYid!J|>o~
z@R~R3f0wEIN91MXD*<}pfY4UW@L#6`qF;a7X|T$0Yc$E11PoymQ@KtTT0a?oO}<-x
zr4bzJY5{*2tNZU0qKMi$5ABVjfMy-7ohDyk+QuESoEb{E_KS5OTQVblKJ_hxt8@K=
z+f*#E{IORx23DHsxN77D;o*C)fy!pQa70blrh66H#)6o3S9fM@vwonl%L!vo>WZV5
zHFiUu%U%m!Yj>_Rx0_>w*dLM!ql6AT#PWDU`8`rI(#vITod&kC9|1&{r&+(v+jCHk
z0uJ>P?6Pc*#8In%?ulEO38VsFEd@_d8UA#tMONWto9Tt}FkA5JJ|`2AkmE{(Oz5c>
z@n;6hlD9LFe0&@L3r~jQKh~l1v!U)Q0rMBgobm1jZPLbc{Ccfk3yz~zLoQ<f2oPZm
zPEvS?1*M+r315@9)_nd|Bt@Ra7lq*Df;z+Z?*=UKp!&EtArGoq|9Ff*haMo>hDl|E
zm_sU?8xI27dKaA&0TillXxJ%#%g)IOaDRlL<LVtiD%1-#3=O}5SabUXKxF%8QQ_e~
z-&O+S!q^_?t#M}9Fp!G|XaJbWKw1Zo!HytY;O;2e1Fli49T$q7<v09egAm*?10$^$
zGwm#}rsu!DSxKy+MQafo_=(IO`b}?Lv7rK*4k*WfP9uPAWoMguc~NfXgB2IZhk{B5
zI<52J-yX0Sg2@;-v4Jumpf4{@V6YSS{rUyzb_5!6pkdU;hV7dY$bvxu1yRq8p0K7Q
zBRjb81d%dmbNckW0ze6%-~bHWfVu<VUVu5XWdS%?0;04|5kLwKEgw&@hK=t!ecTFE
zjJpyZo(l}H+=Z{ca@78#aS*mNsX8pmv=OtKZ?~{>86)yX1^A8L3skUifQB3`whADE
zJvxdH1z?9Gg&<H+jggtNs{<&uUa5`=5Pbhm0hDxrwWW6pHEm5}V-W}&V<vz9{`bTU
zm->b0QUD3a5Pl$mej&MhfW?Cq0q{Un?lpDnh_lIyigCK%Z{|Hp%<eRkCOMmC2qOl?
zBR<^g(nYB%Z4T-A27Zc=4G<XuhRPlFqo4zEAin`;m!x|f>G5{usiOvnd9Tyua%Gm@
z@yH51!^d!Ps6tpt{#zCR<u@R30v>7h_VxKM4Shs06nmCe#BB8pe%#hfeG=_B>7ne$
zSG(dYAW?eHc8KdW1;SZ2wR#06!rp^lm;rtzg^Y=PJ#Dh;fMs4;$(^e<JvIi^*1sw-
zIzL71ILi97s7}Ra18?qN`*oniZuG$tEYx^Vx!fwi`)?5j$xf_XE^!!YaWPQupVQ`I
zV`6GuE&&~?q}a=(ry4APNr4BY=(eiWgMl_zpc*!H3<|XXrOqS)cMj<a_fZOxSV!&0
zBxhW|23f(Togl6MaRIQAXCL*vI|R(`LJezIS7LM%Zs4d0CM{qn7TB=_is_(@V+C<1
zK&*{Ww?P!+y2t@8{9n*84j{#eiGWoAe*yp&6vS)<0E1^v8S!_KJft21ES*Br@16v<
z+?8bWVdGIr&09WV0!xN84F#^GJwV!N(2pM;<DaT5L5Q6KNZXZ;RTI2Z&`coN{+SW*
z5=|H@rfmRHssGREC2Z()74twYW_Zh>21lpDHOGInM<)4u_TPCf`MrMwhIr{fZ3lo(
z1~BwC;`o6<*o&lW->D1BRBA2lpYp%zOw8mTa3(#XLTm&$d>%T6BXrD(qFLcJ?RUeh
z<mOnu7UM+O#c=!KM%Ue$NBlr3o$vVG${5MF_PIs6!n5pL{FOfXp0aZ|YoSJONo9wi
z^vG7I5&_UGAae<*yWcTzMjFCm+f)aY!3?S_f>3<J&Z*q<zMX$&6wD!Su=SoI(8d1_
zVBS-5oai>FfFmo&(pM6T=jR9d<%sFg(=p_*kiD!@-TUo6x6a@$?Oq4F9EuZb;)kHT
zr}<7f+j#z-aGA&N;PBe{LLueT{mXzb-lc>QIYmdOM*TKQ#h1E1bmmdJpBWK$P1I#U
z{;_O$E|S+?(+N+0&Ti(sn@(W+yH049LsWne!A1gSsq9RYd@OC?@sm&Tn3z2?DcaTi
zG~GlX$cEL$LZ6;;@BYvcM+9dTeva(3L?d+uT4L$GThbF7i*mb>p~MsOmgAw^Uo^0p
z_LDH#aiu1#3s>g0i_h119JhO(QM8nOsL1y_0-|NH1+H&nmdnY1F+IH<9Srx*%E#o1
zIh=k+EIid`evcJGN^Wd^zMXTU>l5ci4x^rozjE%RB+_A43gaQuWx=ik(pLx;sTevv
z@j_yqS!wlj366*aRP}h{SK{MdkPmpcwWpRQH7#3EMzjPz9Ua|lVgGj1L}_bnJR)mr
z0tIO|xrM&BGL=4S`fV}JM<0hR5pG*lx%}~^=cV>JTO;Z6W0j2P&yUlyW{O@vG+x~2
zpFQ*_HY=xv)z=%7ld|eG+qrsbOFS&sGZtv_K^eLSL6KS0$tq5}8<sJTI?~F!#&aQ=
zAuB!$b7yXno|+XoE=%MXxz7izT=hWzz5#!FaoRb7l!<L<moMkm4}Vp|0h_-4238-q
z^By%G)Cyyr^98+P;9Hhdo~`A5v($^L!_Ah^!V+J<>@b|W7qo)QlovU<p`C%8e)j}b
za9vqP5;%8H>W_xPi|f)T2xRkxo5x4*!Wwpj&X+~t)8%02#Iza$H<PjrR=LahWB9t2
zM^^v=k%EYc9uj@~_)Fi3wv2_@z`MzMCn|?201uOpD%Jk_q`ueMph@%goHJfk5Nf$G
zml|<)w_<R#@6eO+^qT?a2C3Ky4s3YjJtISMToPgN?ZxV0`k+isz+Um{m@#bv3oM#2
zmv38LO4&z2KcMatJE!%H>DF++^=7dduTSi5Qg1=i)QOj*vsL4Yyw;VtJa3QYw!FM%
zdZ_jLn%kJ(AfK}EMyjtDc4}|7TITXkB5IEB=+s{lqy!ovEXPDCqdxmf?`}|Qh+V6f
zlowIo)}>V5eOZZQE@UYx6!Kgj%dIv}wZ9ywSW-D^C1Ihy`KUc$@s@?0W2O3QG1*lI
zC{u&n@0*M9ONiuznfk7A)qr<t>6vM0@YPafi=uoyBs0#SPUAr8=GVRe&aK|cjd5bP
zmcISXPGzy!@|N|)<*3uN@`TuV%cB#Y7g_d6Aga%M`DF|hGYZ^S<=#Z^pF7uS(+7Vh
zMse+RUis&X4;0cj3d5p>MHf8xwMFa=KspJYhxpv~piA+g&hG%jH4*D2{OpZ*sy??u
zJ>JVo)Tq9@$x{j1h0szMO1)SMcG;sQI;i~;;1iRV#elV-BK1{LUR#saL&2;QHT2uU
z7;0DiV~goyV-I-_8ki_NF+5E~QeHfU@p?7tj)y)56|1rGpnvDumuGoyyt6$1hjsOx
zPh)Em&sLe|dH(ztEUQ9fAAYyvzMI6WKqJqlUl$LnkFFq@u<tZk#e${Zi$jHpD&tLF
zO-hwU)Yl6#2-3i6d>wUpp2|yN7uT(9sd+Eq+`sN%Vs0&q*SZ+hyx8OpStPJc3;E!9
z7kf8W8U9z+czIdbuRtTF6PATXOPEN)OlOy6Likww%a~Y<`}UYVWJp_d;$6`{WGEBE
zn9P_XOl75&Bx3%ya^;RmKG4B;qG}SqXxX>#<3TskY_a=(^shEvnUrV}COQsSbhp!p
z;mu}6GdF$wdoTLycJliP3YZ4C!3AtdMHtkQdf@ThNG0{7S;6cCrT)WL-Qmpaz4^u=
zU#2$*JC$!$<4r0Vls{$7Y@J~h*oJO=SsZaHq$N4~IiXx)#_f{)^qa}@a$o+f_36KT
zl13jo$wE*A(BHfME^v-V8y80o9@&M>Amc1kI1r)u;fJRtNr6Bl$I2&h?;_p3SWI4Q
z7F~V}w&sVa{Qi&Yz|l@&M&Mf#-GOeOc$m@m50}ZC0%%di_H4Yi&8K^1di81OD)s@<
z<3ygCmoJo#uf2w+ns3$)6ATpOiL46SHIJs-bKgT~$9g?(v($xT`t&`O60o<gv#%-5
zdK`WYS1lbVvLb309jXTM@#5-#FS*rQ>s|H992<(oDM7gdpG*sYT^x^x(YnMEu%Icb
z_!B^4#%E6Tu6TmLCmb)d&}M7+D+gB~o?dnH@n1}WwwyUU&3N<wRuUiu2vZGJmGL`$
zs`gozCCG?N`e{b!pjodB$EC__VHitQl1fS}4|^geEzIWBht8P6Yz9^(L*z(fL{*Yo
zq)Zp0L8U*yt?u6?{=#z&^u883Z0c<u1C{%lHfhZjA5o9<v)6$g!gn$&KRD%7Qd&$w
zWsfAq+v|3C-+BHV@7wLT<`q`ijB)Fo;K^N;*{$&?&%~#pg-*@iez|o;RNf&z1))86
z>#CD?!G(R831uU*Sbwx9dtbEw)otz8E>|X>+^aeEQlc_`4I$z%JR(U?7P=I~kj!+s
z-7bdX(!>5@*vD*l)91HjV}<kMTw}H%Rv{!&vQ-yh!$?g3%I?2=^s`M^-xs(3u@3&C
zl)~oj{3jfEeK?)Ml-k(d4VX*?eXBDX>^1`AP{=+%K=Ud|!j)sTrE9Z&Dh7x>KK*6w
z#9H9cYetI#&+1Dm(3*B11)1&?G0huNjnY?zW0D2;%={#`Ca*BD^~4RXdvuq6K_daf
zz|1~Y-#Bq4jp(%GytMp8-|!8HY@|*AAnga3KZ!?v^UO|UTDi5Smp}8jLoBg0Ag?6H
zWSdt1<pk3aSmJqV9cu4N_eQgxYvtB-E?9w-_{Syfycnmr#9xf`IYFQfia1xW<gWj7
zEvXFNYkLdPuimI|))RQ639B0((GHJ_KcyYzJ`Dd5t!wQ*ISOXBj9J9*fIbmLSl!s&
zFo(GC%ZLQUp9_hKCNcha%u;LE%g9qo&+v~Euu>zY|9b^ch~2x2(J{^SP5QON3qyKF
zUZ!SOq4x2*mhURl{>KnP`Mo!)`IDkEQO=J5C)hYDnTkp0%cBH~pA@_|czpj0Lyj6l
z>yay4vp$p@tz#d?6D(|W5@s`!^0>{8jP>{fq$4@#K5_(y_oK8jm_1atDKJ?;X14fT
z_7!Su9A=(9&4JGGv{eME;Qitb)>nc%n%E#ptUL`Cpgxt{pT!gukA89c3O`;_Sv1Fm
zR0okYfTo(?&7s!o`I&T5Z01eDNce<0&W&vD9JB;ekM27;z(w3umZpsjWSIqB_wNbK
zW9_bm*l#nP6ncQU5BPusN=)&M5lYn*ot7ZweXUYK`hR1!bguvrFBC^@8YcGpZGBO9
zN-Xa~CX<hJ0nhHoKumXk#E97Nzk&Z^Gw}WYJpf_*Kfm$6E&ey~e<DZ(o9n+V{x@)+
z8iAolJQRFw&E4kJujs-5c31$bj}IAaOl5k%J<v_O&j`TD{`c?a`yd7U?Ef?Hzk~h1
zTl{a}|9!CkzmNX27ZN(cxbxpmOwT(|3<qKRyDCHPLO_58fF=|HxxRU0Jkry7X&h15
zr{*L!w~9M=AfZC0%a(e{IyPf#iSu7=A+i7@V9@j-5^OZUcjjmT5>%m_2zjf&*1R%}
zI(MvPTSGJ<D0Y>fmEyNM4%fO3ecq&AG*u<H#An>K{P+;{C9Co1ysoIxB9JV)8|i@`
zM3w6ucU!QOPNyMN)=&C1n@8rlgP}cp&&gwhyUu5RYG=KQt>`ALVq7apMZw?>4Yhm9
zE$YgUg(k^J*PnrhhSyD&gx-P8^+)q;k9tDgV6U{Oj4aSG<<|R=#o%xhfShLy(}BU+
z*+<kUj3m0JFuc)fSC_?BUqEa>+r|8hN0&N4CFGC+D(cVXT|fQ1a9JT9DLXXLbxE&p
zcKL-WiceTF_A&Zl0;<Smy6L)iWl6L>c5&?djmcqZShQb0AU6PhV?g~nAh2vLwD^qw
za5240W)z&(Zn#;}#d0HUC0w$)Wc=yahFM9BrNyy~!%WKni@Oz5+lq?%LN$F6S0)^L
zD$!S!6Q{unRU!v9Vvy|{1bgf?A{48}e@LS#EcPfuqKHtpo#CwAfwuaQsNJUzH4^MK
zntOG$2FqZd8FLtEP+-T@80@ZQjT!~`$!l>c4esI^QjoSng~!Aa=6G)!+LH(~_4RsU
zQ#CZ*N|<!=EzI#8Y;tT^S7~;2n7gZN7YdvjUiQJ+ULr$fCSU(1(k0=@A#C28dgVR*
z@!3iK6IY&ic@Kp{JQCC}JSZg7<ix6@ifsxW@1z1`7ss?@d!20h9)*^&VG*<S;j1-L
z@#wzM#Z!YkcysZXqYu7IQ}i^K4^=+Qq|lXUj)(va%g$ma^nOP~XmHeS=u9QpNeg~c
z$xo$xwx;TgKZlA~35@T46Gh@MFJW%FjV2^SH%!Ib&cbcc{fI1y>74x3<iwdXdShDx
zRN63IN?<OAu>1XGPBP-^!EJNZv}9*ESZlB1XBezz9f3~!!?wfRB6?GdkZ{ItC1%sa
zuo^-^%qp0wUoML(UNb&ahY{aeyUp;R(+Gy=bU5d8cLO*t#tlwpG1Ni4a;jbg&DYpQ
zo>BgODiw{If9+-+C|JK$$&b2Pg{bRUi!jgPzST`&V3+YNVa%0y#;Ojl*flsv5Uu2p
zt4&uSP`l}Y+tR|QYcUCN9{-{CTTIX$l!P!-1!9x&0FoXC!81Tl11ub13|$MDy=)sF
zk9#uDm*UUok}KG3X8alMg2Y=Ec=ekvW6yu*3i%K|g0JNM(YY3(*n;@{o#g1++MQa!
zL?U2u?9sVCBSx~^ZMC28N;8iXfwpaF?Xx1m&8FdIA_=io>I|+dw)txC-M^R>Nb)kw
zNZr1+4+TmxKD?Ir5tk>Y`hcDNfMg@l)g#(RgEA~dQl>ISDIdsG>>=iejzCbr14bVf
zJjqZWbzFnUgV&B{!k(W<c?YEohxkiA9Y6VgLu>cxk#u#^3y#q;ISNrB^zxk^jNg7e
zNuoTAI!MhY9*AQS2Ix1N4t!q+zB}dG>#7DfqpoA3b^7+?+EoXi_C(VyA0@D>(j-nN
z`QxhX!&eYyG;`1;WI3Dx$k@Q42A0ta3>qv3QuwXM3%ssQOZ932Td~*iD?-D!FOf5y
z|NZZbSN=fh2w0Mg09g|xUi1DW;50F9k^Tep8-X^OA0;I=OYH~)&?SHkX_x36fWDgJ
z!_+6dknNAl7O4+RTwM0L%8kQ)lKn7VSC&3FyW>nN?utx3SoWwt_=v>i#b$J={j~+#
zBjuoj)$v54#>}BR?32^>!9YST*IOhz_XjP1Fp-Mkt9Ez&kU4Sk#E6baf1Mi4rj&o{
z<yk%$^Vh<nzU5+3v-#O<s251y$Bc8ekEHiINVH5`_~+{%aPD>;JD!g_d{>Y1xugHR
zkNnyGmVK`tJFRsz(XrdC{uHBRAz+rHvo^i!T<$v@_pGF&_)6%L?1-yVop9fu_?ir#
zY!p%2fY0l)L;j38(G9NI_ze_qRGb-L!OX3pP*!h2|2KJtBb5+l=riRs19kQ6X`;_I
z0>IpAXx@Fhv~1gZQ{EWUE**4d0BYXvQvHu@s3iSgpA)o#)+=ImJq>mBBj9>dYV_kt
zD-d`S2UmC>_-p_tkMRh>c^%#9S)62ny)KvZ&Sfhm_1jkQwdJ;mq-%nAqMjgj5^bXV
z(6zpI)1LoNNvvqAV#iwHl9b~PwYlj*%O%|)nNvHl(QMGZape1FX?P{>Yv~Rdl<S-w
z>1RuYs1B&arO2O$I9_jYh+YaCdEyRfc3cYB-S{^b3mSwcx~?>zkQ#@Ga6bGjKiEFn
zpmWK?ar1mFT-xk8lIL44szzjSZ`4@taGWNU+4dOuP%n0<yz8m;84@j+YTS9YdrMe(
z$zpm!6|~+}kGcdf(&SS2j_%62utg+=XI_%t<rCMd)s2Zo(8CCYL9ra*ZM2b9jw@>e
zsX&X)$os-<A{t>~1)jkYg9azy+yYA8=v=llHNYE4{Pujs{>RC0;9~>&Yw{IS;pPJ=
z!1>8%EKd<=WCFv<-Bm%CtFU?tF{-2pueud!?RGfQV#|Chf&I!KDbWJ~DO{A##&&J6
z%%o#(r24nWY14tBe9b}_;%-EmF6XPM=kE#D(m%E*l<WG|iX7}fzh5bOt|EgiMPG2E
z)RnZAJ)5h3L=g0*x4WsLm~*GK&O3_w8iTdSVXgJ+)~--+kic6Dg61CrXB7#imP00|
z&t*hDIhZOx69da98=DjR3~fMkT67tstu`j@hg@ysG{!0p9$m+pj_qH;C9Gn~5L(H>
zpvc*%Cm%v(w<JTfHFWyYtqNSYa}6J>*#JQY1o-pa3%q*k-#*R*)db3JRh$ygRPrqh
z?b79|#aBlu(2e!)^Mi+I09{YDYh<p^J)_qt15bVB7Ui7S!#V>$_N#;0(og3{=S_}D
zLKMv8?A=HiYc%thNXB1Lkk%h{a>7k?P~|8}lA?%?KBPWz>B7)2vj-4jka2SewSjNC
zQH1#SpvMo9GB!C1FnZ4(J^M3(tM{RWuZDIPsdX5W&zWj}7pK8EC35*o`bt?#w@BE*
zu?U!K`KVSG86=<Sc>lt@J@oTVJT2L9VDrJDU|zxiOVmluc8`LVGf=h-`t=UB{VLdi
zIl+w5-a6O(*stn%IAPEFr@WVgf-*YqrDQi<PQet=KGD=R<abzX1w0{CK_%cc_PazE
zG!Fg&y(ge7Ov0v<QASi?n+XKbHEX~uHtB-!G6u>fJ~j5X%2>^Z*m<55>fISxD8|i5
zlP`QHPv73Uo!@?)GfkTh97@MxKIk<Xhi4dL>f%n8w%gA~&K|zMa+q+UXe1{|54kCg
z#_ymKYWwsoYKN_B*Wk_XNXzvdGOQ<*mfdq7KD0zpI9#6=314@}8Sp*v(Sgknds?ug
zb27I>5@6B)Pz*?tOB^U57~PLQGvqppC4XS6<JF!@W+23GujB1>LG~F<VNQDg7|k!Y
ztDs+Mcjl|a3=wT-Kd@5<;wm1qwsm3`e`9@VfsZkS_7rqdy3NNit1s69<wJh^`R_o2
zkLrb|P`sS&bQLh1yXfPeG#CS%TW#%+gU{E2g%6rz`TUZ!_Hw)!9=-)mSAO716FHY1
zmuQIX$;Lm2TD4cTS(s=2FU^415jK*vVaaU3Y+iOI<v!KVb*b#4M<S_CxM@Pzlip7>
zsgYX0Vp#T>99<RIceK%;54qLbi(Td(2vT<();TeMABu#A_zQ}^TzPCDOdNmXutqaZ
z@vHi1$gYDuaS=>vvpzqy#S@zj`hAmx(ezKV;bgmHH5NinvZ|O`>-dACClb<V_`e#T
zll7KvQwSw|yv}E&kt{<`NTI;4W&L2CnX;yy{&v=No(Q{83r5He&=&awHeJxz4c?E<
z*@-H%J^{Nqgj_zb&aDR$dna2H1kV(Lr`r(%grFOM+^)V2z6;hrc73?$>6B?031>49
zBYXfFqBwP{auOHD8(us1F*u;Y1sAu6RyJ)(jeO<1vo6i~s5@~5mY2D^vkl63JI1-s
zCsG^qn-9cwxT&|Bv5{&A>a8yh2B><Lsl_8a%rnINCl|WEcUSJ?AsN(Ril+wI3O;B}
zx30WqAFo^LDLtPSrTB1gfPQc+VDN$py~Q8hxZR8VaOXPjN4*&iSh%oW_@_4qnz%#<
zt(okYAbqkDq;d<OPel4W0X(x{VK`R<$<P%Jj3%Pvc#iCZRUw(&k{Z)oHMr@+1cqEf
zWT@Oy+mR268iW}oM?%FbKJ{~wiPuYBKcd=2n($}2di!W6x?uVQrd}(p3^@*D&z;^a
zd54<1-kwaShHZ&@o1+vp`^t)U!2|b1Z`x}~Tuy%3&(su>7mqo;nvI<#av9W(4)5I-
z=uD!Ei%zRplw)25P4K_G>Ct@PY0=SiB->v?^-#IFes&dS4XRr@V_vuma`^!QoEI#l
zgX>OI)Hvc4d+%Gw5B4cXJk<QhC<>3$vIuFBAe*xC5G!4tNrK|)vG};|h&=hXV>mcG
z{+i>=P{?L=jfKOArKcGt+F3^`^<tx@18NjzrU|8B(#q~MyW;moCQY$QUi|#gB?v9-
zn9u`v>8Q_*6oSh7B9cM*9}5(W;#I_o=)_5bZ;43IHaZyIvYU}*@e*>q$rOCuP4z5K
z_=%enLA$9W;%B2Bz`77<9YpIz%TbEBvTe;DcI+SieFp0eMVw4d5NNp~=d)Cy-Mau@
zQV6ffJ<3W8)Tis?3@<}tYT4rRO&&ubuW<7rsVOOeIOKpUf<>ooIqM26#6TlCU?7^R
z!5*d>QLA1F4cQw>-JDeNrqult`dkgcpoM+K>@F%OU}9z6zS@Ki9RVA%-&0ehY);gj
z$s#_&HFg6*ro=T`Msb^hUl{dr|62Ybi%6B;F`O><5{yDa4O^s7#&7r5h7tOk0wxUj
zq?zv*8(-}?PT>B##&0L21s4Mfxld7O!S&B_Aeo4nLq}XAm5R&80p}|QOFghf>)<|N
zNxLTN-C2}`<zcg>v~&<&*2~$K1mJ$4L4$!S&C1I*7L%qgYSyk3AD5+W)4;l=UIDJo
zRIt^79FvaMOqoXQmSWS^mOOB);NFsl&=Rsi+gM1OM%%Ti-F8@<(Gfk-y1G5?Y)}y9
zgT|i^A9$l4PUU4f?8?b8!&Llr@;6*!@h;~;H}NdoaB_8u0ft8?t*qDW*f<lL(C~=M
zZz6xEm(6AWJ%G@_`T%%fA9nDeGO7mo>V<&CY$MS3`hiph=C4ZVF3b5JVg9dw?LcRI
z%XeVcBL|`VTf>+-kPsga8i9{gR4Op5nEiF9sFI>xSSmphwOcUzdjG^8D3y|NzeTyr
zpoK+`&6Y_;Qh>hTj@J+JAXwafW&&nh6D)Fr<4rknZ9cWfS*I0?^TX_^v>dxcH&i$v
z6HDc@QhWW{e?^F*8>CDrOO1QMkLkfY1j9248$tewNQb{1y$jU;l0N=Ir=L)7w9Gw<
zShn}QwkoPo+X%0*u-u>V{G==MS@??3tr1{|gAOCmCkTth#Gw7lmkk1Rz&ZF+!HTI>
zhpRf?so{cVO#Y=_F|-;|yP%orOu<+|#(qvHs-s@En2<E9*{0@i1hP5r*6W)CALN44
zQc9k8GJub_-8gOYdx32>8XpS5EY)tpYp*H+*4W*SfT`uWKR?ic49?g2)+DYHZHcwp
zQLQlU$xj}7oxEf#7sE{ATn4&YVJ`Lw((|f2lZgu$9%$bJ89z|m1!OT+K!xDs1ftUv
z(=a@>m*7qT9SZOP)OgSj5zAa@b{-1uqxMHFdY#A>%N72b-*OQ$R&N*;JNcT_sLP3*
zE|gX2)qJlD^&JfBK*Km-&)3-XUzcm`m`P0@O1-FUygKKn@E7{J?q<h$dv)Rkv^PMT
zwlT#(PEmsy{~OBdRT2t^-2(Tt^_H@Ax3-RJbd<{0MMCt{L+bDfC*dQ)r#9D_5gh4@
zxw&y|RA`L9#D#p-iXUt(a=%)hkNf1ZgBsNCV{H9d;QZkX1y`mIJ}iyIkxtcq?yG8F
z*aO;edQ7dy5&Of1o_U5=lh04|h>mEvDSw@@?55<{Nf4DUZe~t;Pl)zgpb8V|DdgGm
z@=X?c-A?Fdg%4D*-Tkoqz&jyYs5eh?5}IdnF__uR`QhxkdkS6}&tu7`p>A|!`8CvD
zdH0W%sg&5Ww&xR76Kh=Z=es2dgh{Vit@Q#M?%Ia=zlG%b!iLM3be=|GBy&Giq!|y(
zwU*CJCmxvcOOjLgtv34r#;!ss%-<Gn8X!dj%@?yidABto*uyHNxtE$}W)$ylVHIiV
zo?~yHC!Tzvdo<TcQp|ARKRj$=R2`CB$?|L;2?-5XR^pXLVv(&@susSGmVyo2#b9yv
zr0DmVH`w1UpKRS2;;S1eK{ls{kj2%(<e|cPgju@!-LFdGF2!PyfRFQsY7eLFTR(Ty
z2~nCUr^JL~?jv1p5-UaIWzOU+{V`;dHJh+S9V>F|Z+&F$7f}mA1;5GNL<Z0>+U9k4
z^}YUNd{ye}PG+ItZ9~S$Yn5O(#ryCn_GcE<FaZzBnq@+CRT0_nNrGQ@n8n;L;`|_R
zIMjuAgNX13CJ?SdG!RuQff`g3t!$|zjrF+DMKn`;ub`@En1z*hI2S|0@`I=NT8?7E
zxPnICH!DWEPoCFrBQy6^#o*SO2`mAIaz|GAB5#mnz4~U-QtbuYOccny51K7|oh>zW
zH%uZ6Rl_j)M!F!+C9OL_9jaJaMpK*Brk_7^;_ZCKuym=zXm4gs8rID2%!wv1z9!GO
z*kn!rU3p3dc2Qja9~G>Q+7*I0h0Zg@h#vHS(8v_u(Pf93wC>|!T=r8;CD>&cSuqyQ
zUlh)7b^YQOZ>0~~7*CFq^Sk1>c)ujRbGMmi$h@Y6C<t<SyCi0<^#n>?_5XWQhf6~X
z3TAD>iVCdHmX?j3YRJ^|I=Jsxayyg9Dblz2W>7j*YDYyojzq<a{@(FTNED-~bH-W=
z$$e8?b4#-#H@Au-tK_04FavVdQXa-BhK1IojT)+lxlOg?uWfl)uwxyl%(Ne7VHoRC
z5@iNla8HjGEM^IuajDdq%oS;FWts}*nU!rid~d}Yz3ND#X2R4;uPz>zGvZw&{1mdr
z*M{0(SN!sGKU~LKZse}e3Rb9PPR_2*pH*hPHZJNS?hi+uArdSKkgyEob5_n`sW-KD
z)(GJDcq37&OBj2E8If&i$kiXuwDM5Ne3-+$?CZs;>6bum2K6>?_cW3emI(Wlj0ldS
ziUN<^XR@!A)h*4rYFyd(gSXl=hcGfVM!@^x<vuK}csaKG`V}s1sXH^k?LufaAVo%}
ze)TcabgV@$MOc1(snariAGf-1RDt_Sz2LmZQq?OhL&2g?Bw4)1dRC)nILzJhVZb@5
ztVV!GflKF51MfORk{IU~l8fZF(&3Na1Q!xjDzds{H)2AfA_{d4c|R5ong)-0c@N=l
z5oVeYnc8|-8a$0IdfCF)7Alufz`9%T14*NeC*Q8~BY?AK2-Phq2w@kKlH!=lcgwT!
zPh{kU&W5q03-U;7JMv7D<2QqCHKPSJ2o}<4Ud+W`H;rQd`1y1*ODh>$5#q`}K|1!}
zsr{1n#-WPptOk0ut{u@yci^U*Nti0Mz?rawjyf(=mZ7@Ob$p`F;HJy*tBJ@O@fS`3
zG6MYI6g1K}{ldV%%&-*c`G}7mIQzp%a$k0zevO%&=$K-tl{3OIH&4$V9R|gyHQUJO
zxqnbe-V1ryVE-_k4);Um=1maLxJtGO+rF>J${Q|DOdxII@khxd`7#V$DU*BIz9;<(
z3#m5DD#L&~%r|{&Zx-XVP`;&d<AEZfCOUB~bM;tBLYTr77GDt$n|%Z6q2@=I!qvjd
zyngr-x8j-XCpSk$FCn`iEbI20#(NN=Egfa0KfHpULBxsfN@TD<5dBbgbd9BG(^GIc
zdo6kE$}nw!3|n>$JFslzCxn=`1}vO0!djNk$7PMaM%UY|JvDuv$-g-xEUM}?dVv}v
zc>HCqY?(w(j>oF9+{>$5;YqNn)KNXd=9(lV(@?cSNw7O~GkF?^9^=Q9^N>~J*(;uP
znXY3#I=3VLKdF+Bg++L3u)othn|-F6F{}Uy%mV=);%`1yWEtn{`-(APAx?C_8vBpe
zjfc5Cwr94h#)fHbEG7q!{f&hN6mepjY_A2Ds-EVj><x^p1XbgDClWO(odo+jjz5Mr
zWtljhpN3qLdWR}aCcrz%ke|Z-WxZ^pqZmdx2-7$<iHl38ghIqsK;RY1ZPvdp2Zc<8
zs#HK;agwxx2o>?Y02Ks#8=5db$;+2oh`RL;FnIn7)eL-RLJYgFJXBZ!LGcr!Op}=T
k+fQSyAXL1SP)fT)Z$9JZxKQ|mFxWzpl~j@_gPQpLKN$VEy#N3J

literal 0
HcmV?d00001

diff --git a/images/pm-lora-filtered.png b/images/pm-lora-filtered.png
new file mode 100644
index 0000000000000000000000000000000000000000..adc1391efaf16d857544371a0814049dbd68e900
GIT binary patch
literal 38620
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
Ax&QzG

literal 0
HcmV?d00001

diff --git a/images/pm-lora-import.png b/images/pm-lora-import.png
new file mode 100644
index 0000000000000000000000000000000000000000..0e118fd28cffe620c79480768caea4aeaf430404
GIT binary patch
literal 38408
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
X#)jA&heaCx&oxO=Igxy!w;%rp=B22b

literal 0
HcmV?d00001

diff --git a/images/pm-lora-results.png b/images/pm-lora-results.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4e3b08945bf65a7cbb2b491f660615e6840b635
GIT binary patch
literal 34717
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

literal 0
HcmV?d00001

diff --git a/images/pm-settings-integrations.png b/images/pm-settings-integrations.png
new file mode 100644
index 0000000000000000000000000000000000000000..3168180615133c5acf5ec5763ecf9abcb517b3ab
GIT binary patch
literal 45680
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

literal 0
HcmV?d00001

diff --git a/py/api/images.py b/py/api/images.py
index 95877f7..e6b06e1 100644
--- a/py/api/images.py
+++ b/py/api/images.py
@@ -322,6 +322,7 @@ async def serve_image(self, request):
                     allowed_dirs.extend(Path(d) for d in lora_dirs)
                     allowed_dirs.append(get_lora_image_cache_dir())
             except Exception:
+                # LoRA integration is optional — skip if unavailable
                 pass
 
             if allowed_dirs:
diff --git a/py/lora_utils.py b/py/lora_utils.py
index d70620c..62c925f 100644
--- a/py/lora_utils.py
+++ b/py/lora_utils.py
@@ -28,8 +28,6 @@
 
 # ── LoraManager detection ────────────────────────────────────────────
 
-_LORA_MANAGER_DIR_NAME = "ComfyUI-Lora-Manager"
-
 
 def find_comfyui_root() -> Optional[Path]:
     """Walk upward from this file to find the ComfyUI root (contains main.py).
@@ -52,6 +50,7 @@ def find_comfyui_root() -> Optional[Path]:
         if base.is_dir():
             return base
     except (ImportError, AttributeError):
+        # folder_paths unavailable — not running inside ComfyUI runtime
         pass
 
     for start in start_paths:
@@ -142,6 +141,7 @@ def find_lora_directories(lora_manager_path: str) -> List[str]:
             if pp.is_dir():
                 dirs.add(str(pp.resolve()))
     except (ImportError, AttributeError):
+        # folder_paths unavailable — not running inside ComfyUI runtime
         pass
 
     # Check for any .metadata.json in the LoraManager dir tree
diff --git a/pyproject.toml b/pyproject.toml
index d782192..04cc3b7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 [project]
 name = "promptmanager"
 description = "A powerful ComfyUI custom node that extends the standard text encoder with persistent prompt storage, advanced search capabilities, and an automatic image gallery system using SQLite."
-version = "3.2.0"
+version = "3.2.1"
 license = {file = "LICENSE"}
 dependencies = ["# Core dependencies for PromptManager", "# Note: Most dependencies are already included with ComfyUI", "# Already included with Python standard library:", "# - sqlite3", "# - hashlib", "# - json", "# - datetime", "# - os", "# - typing", "# - threading", "# - uuid", "# Required for gallery functionality:", "watchdog>=2.1.0              # For file system monitoring", "Pillow>=8.0.0                # For image metadata extraction (usually included with ComfyUI)", "# Optional dependencies for enhanced search functionality:", "# fuzzywuzzy[speedup]>=0.18.0  # For fuzzy string matching (optional)", "# sqlalchemy>=1.4.0            # For advanced ORM features (optional)", "# Development dependencies (optional):", "# pytest>=6.0.0                # For running tests", "# black>=22.0.0                # For code formatting", "# flake8>=4.0.0                # For linting", "# mypy>=0.910                   # For type checking"]
 

From a02c79418c3d93b30914de52ecc5f47274df9c83 Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 18:21:07 -0700
Subject: [PATCH 23/24] test: add unit tests for LoRA integration and folder
 filter (#52)

- test_lora_utils.py: 32 tests covering trigger word extraction, example
  prompts, image URLs, metadata parsing, cache dir, TriggerWordCache
- test_lora_database.py: 17 tests covering delete_prompts_by_category,
  folder filter search, get_prompt_subfolders, LoRA import workflow
- test_config.py: 7 new IntegrationConfig tests for structure, enable,
  partial update, reset, and roundtrip
---
 tests/test_config.py        |  86 +++++++++-
 tests/test_lora_database.py | 253 +++++++++++++++++++++++++++++
 tests/test_lora_utils.py    | 316 ++++++++++++++++++++++++++++++++++++
 3 files changed, 654 insertions(+), 1 deletion(-)
 create mode 100644 tests/test_lora_database.py
 create mode 100644 tests/test_lora_utils.py

diff --git a/tests/test_config.py b/tests/test_config.py
index 05037ce..8f90862 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -19,7 +19,7 @@
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from py.config import GalleryConfig, PromptManagerConfig
+from py.config import GalleryConfig, IntegrationConfig, PromptManagerConfig
 
 
 class TestGalleryConfig(unittest.TestCase):
@@ -207,5 +207,89 @@ def test_saved_file_is_valid_json(self):
             os.unlink(tmp.name)
 
 
+class TestIntegrationConfig(unittest.TestCase):
+    """Test IntegrationConfig for LoRA Manager settings."""
+
+    def setUp(self):
+        """Save original values to restore after each test."""
+        self._orig = IntegrationConfig.get_config()
+
+    def tearDown(self):
+        """Restore original config values."""
+        IntegrationConfig.update_config(self._orig)
+
+    def test_reset_to_disabled(self):
+        """Integrations can be fully disabled via update_config."""
+        IntegrationConfig.update_config(
+            {
+                "lora_manager": {
+                    "enabled": False,
+                    "path": "",
+                    "trigger_words_enabled": False,
+                    "civitai_api_key": "",
+                }
+            }
+        )
+        config = IntegrationConfig.get_config()
+        lora = config["lora_manager"]
+        self.assertFalse(lora["enabled"])
+        self.assertEqual(lora["path"], "")
+        self.assertFalse(lora["trigger_words_enabled"])
+        self.assertEqual(lora["civitai_api_key"], "")
+
+    def test_get_config_structure(self):
+        config = IntegrationConfig.get_config()
+        self.assertIn("lora_manager", config)
+        lora = config["lora_manager"]
+        self.assertIn("enabled", lora)
+        self.assertIn("path", lora)
+        self.assertIn("trigger_words_enabled", lora)
+        self.assertIn("civitai_api_key", lora)
+
+    def test_update_config_enables(self):
+        IntegrationConfig.update_config(
+            {
+                "lora_manager": {
+                    "enabled": True,
+                    "path": "/some/path",
+                    "trigger_words_enabled": True,
+                    "civitai_api_key": "test-key-123",
+                }
+            }
+        )
+        self.assertTrue(IntegrationConfig.LORA_MANAGER_ENABLED)
+        self.assertEqual(IntegrationConfig.LORA_MANAGER_PATH, "/some/path")
+        self.assertTrue(IntegrationConfig.LORA_TRIGGER_WORDS_ENABLED)
+        self.assertEqual(IntegrationConfig.CIVITAI_API_KEY, "test-key-123")
+
+    def test_update_partial(self):
+        """Updating one field shouldn't affect others."""
+        # Reset to known state first
+        IntegrationConfig.update_config(
+            {"lora_manager": {"enabled": False, "path": "/known"}}
+        )
+        # Now update only enabled
+        IntegrationConfig.update_config({"lora_manager": {"enabled": True}})
+        self.assertTrue(IntegrationConfig.LORA_MANAGER_ENABLED)
+        self.assertEqual(IntegrationConfig.LORA_MANAGER_PATH, "/known")
+
+    def test_update_empty_dict_noop(self):
+        """Updating with empty dict preserves current state."""
+        before = IntegrationConfig.get_config()
+        IntegrationConfig.update_config({})
+        after = IntegrationConfig.get_config()
+        self.assertEqual(before, after)
+
+    def test_roundtrip(self):
+        """get_config → update_config → get_config should be stable."""
+        IntegrationConfig.update_config(
+            {"lora_manager": {"enabled": True, "path": "/test"}}
+        )
+        config1 = IntegrationConfig.get_config()
+        IntegrationConfig.update_config(config1)
+        config2 = IntegrationConfig.get_config()
+        self.assertEqual(config1, config2)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_lora_database.py b/tests/test_lora_database.py
new file mode 100644
index 0000000..946d6d8
--- /dev/null
+++ b/tests/test_lora_database.py
@@ -0,0 +1,253 @@
+"""
+Database tests for LoRA Manager integration and folder filter features.
+
+Tests delete_prompts_by_category, search_prompts folder filter,
+get_prompt_subfolders, and LoRA-specific prompt workflows using
+an in-memory SQLite database.
+"""
+
+import os
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from database.operations import PromptDatabase
+from utils.hashing import generate_prompt_hash
+
+
+class LoraDBTestCase(unittest.TestCase):
+    """Base class with temp database setup/teardown."""
+
+    def setUp(self):
+        self.temp_db = tempfile.NamedTemporaryFile(delete=False, suffix=".db")
+        self.temp_db.close()
+        self.db = PromptDatabase(self.temp_db.name)
+
+    def tearDown(self):
+        for suffix in ("", "-wal", "-shm"):
+            path = self.temp_db.name + suffix
+            if os.path.exists(path):
+                os.unlink(path)
+
+    def _save(self, text, category=None, tags=None):
+        """Save a prompt and return its ID."""
+        return self.db.save_prompt(
+            text=text,
+            category=category,
+            tags=tags or [],
+            prompt_hash=generate_prompt_hash(text),
+        )
+
+    def _link_image(self, prompt_id, image_path):
+        """Link a fake image to a prompt."""
+        return self.db.link_image_to_prompt(
+            prompt_id=str(prompt_id), image_path=image_path
+        )
+
+
+# ── delete_prompts_by_category ────────────────────────────────────────
+
+
+class TestDeleteByCategory(LoraDBTestCase):
+    """Test delete_prompts_by_category for LoRA reimport cleanup."""
+
+    def test_deletes_matching_category(self):
+        self._save("lora prompt 1", category="lora-manager")
+        self._save("lora prompt 2", category="lora-manager")
+        self._save("keep this", category="general")
+
+        deleted = self.db.delete_prompts_by_category("lora-manager")
+
+        self.assertEqual(deleted, 2)
+        results = self.db.search_prompts(category="lora-manager")
+        self.assertEqual(len(results), 0)
+
+    def test_preserves_other_categories(self):
+        self._save("keep this", category="general")
+        self._save("and this", category="portraits")
+        self.db.delete_prompts_by_category("lora-manager")
+
+        results = self.db.search_prompts()
+        self.assertEqual(len(results), 2)
+
+    def test_returns_zero_when_none_match(self):
+        self._save("no match", category="general")
+        deleted = self.db.delete_prompts_by_category("lora-manager")
+        self.assertEqual(deleted, 0)
+
+    def test_cascades_to_images(self):
+        pid = self._save("lora with image", category="lora-manager")
+        self._link_image(pid, "/fake/path/image.jpg")
+
+        # Verify image is linked
+        images = self.db.get_prompt_images(pid)
+        self.assertEqual(len(images), 1)
+
+        self.db.delete_prompts_by_category("lora-manager")
+
+        # Prompt gone
+        results = self.db.search_prompts(category="lora-manager")
+        self.assertEqual(len(results), 0)
+
+    def test_empty_category_string(self):
+        self._save("test", category="general")
+        deleted = self.db.delete_prompts_by_category("")
+        self.assertEqual(deleted, 0)
+
+
+# ── Folder filter (search_prompts with folder param) ──────────────────
+
+
+class TestFolderFilter(LoraDBTestCase):
+    """Test search_prompts folder parameter for subfolder filtering."""
+
+    def _setup_prompts_with_images(self):
+        """Create prompts linked to images in different directories."""
+        pid1 = self._save("landscape prompt", category="nature")
+        self._link_image(pid1, "/output/landscapes/sunset.png")
+
+        pid2 = self._save("portrait prompt", category="portraits")
+        self._link_image(pid2, "/output/portraits/face.png")
+
+        pid3 = self._save("another landscape", category="nature")
+        self._link_image(pid3, "/output/landscapes/mountain.png")
+
+        return pid1, pid2, pid3
+
+    def test_filter_by_folder(self):
+        self._setup_prompts_with_images()
+        results = self.db.search_prompts(folder="landscapes")
+        self.assertEqual(len(results), 2)
+        texts = {r["text"] for r in results}
+        self.assertEqual(texts, {"landscape prompt", "another landscape"})
+
+    def test_filter_different_folder(self):
+        self._setup_prompts_with_images()
+        results = self.db.search_prompts(folder="portraits")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["text"], "portrait prompt")
+
+    def test_no_match_returns_empty(self):
+        self._setup_prompts_with_images()
+        results = self.db.search_prompts(folder="nonexistent")
+        self.assertEqual(len(results), 0)
+
+    def test_no_folder_returns_all(self):
+        self._setup_prompts_with_images()
+        results = self.db.search_prompts()
+        self.assertGreaterEqual(len(results), 3)
+
+    def test_folder_with_category_filter(self):
+        self._setup_prompts_with_images()
+        results = self.db.search_prompts(folder="landscapes", category="nature")
+        self.assertEqual(len(results), 2)
+
+
+# ── get_prompt_subfolders ─────────────────────────────────────────────
+
+
+class TestGetPromptSubfolders(LoraDBTestCase):
+    """Test get_prompt_subfolders — extracts unique folder names from images."""
+
+    def test_extracts_subfolders(self):
+        pid1 = self._save("prompt 1")
+        self._link_image(pid1, "/output/folder_a/img1.png")
+
+        pid2 = self._save("prompt 2")
+        self._link_image(pid2, "/output/folder_b/img2.png")
+
+        folders = self.db.get_prompt_subfolders()
+        self.assertIsInstance(folders, list)
+        self.assertGreaterEqual(len(folders), 2)
+
+    def test_deduplicates(self):
+        pid1 = self._save("prompt 1")
+        self._link_image(pid1, "/output/same_folder/img1.png")
+
+        pid2 = self._save("prompt 2")
+        self._link_image(pid2, "/output/same_folder/img2.png")
+
+        folders = self.db.get_prompt_subfolders()
+        # Count occurrences of the folder — should appear once
+        matches = [f for f in folders if "same_folder" in f]
+        self.assertEqual(len(matches), 1)
+
+    def test_empty_database(self):
+        folders = self.db.get_prompt_subfolders()
+        self.assertEqual(folders, [])
+
+    def test_returns_sorted(self):
+        for i, name in enumerate(["charlie", "alpha", "bravo"]):
+            pid = self._save(f"prompt {i}")
+            self._link_image(pid, f"/output/{name}/img.png")
+
+        folders = self.db.get_prompt_subfolders()
+        self.assertEqual(folders, sorted(folders))
+
+    def test_with_root_dirs(self):
+        pid = self._save("prompt")
+        self._link_image(pid, "/output/sub/deep/img.png")
+
+        folders = self.db.get_prompt_subfolders(root_dirs=["/output"])
+        self.assertIsInstance(folders, list)
+        self.assertGreater(len(folders), 0)
+
+
+# ── LoRA prompt workflow ──────────────────────────────────────────────
+
+
+class TestLoraPromptWorkflow(LoraDBTestCase):
+    """Test the full LoRA import workflow at the database layer."""
+
+    def test_save_lora_prompt_with_tags(self):
+        """Simulate what lora_scan does: save prompt with lora-manager tags."""
+        pid = self._save(
+            text="1girl, detailed face, anime style",
+            category="lora-manager",
+            tags=["lora-manager", "lora:my_lora", "trigger1"],
+        )
+        prompt = self.db.get_prompt_by_id(pid)
+        self.assertEqual(prompt["category"], "lora-manager")
+        self.assertIn("lora-manager", prompt["tags"])
+
+    def test_reimport_clears_and_recreates(self):
+        """Simulate reimport: delete old, create new."""
+        # First import
+        pid1 = self._save("old lora prompt", category="lora-manager")
+        self._link_image(pid1, "/cache/old.jpg")
+
+        # Reimport
+        self.db.delete_prompts_by_category("lora-manager")
+
+        # Second import
+        pid2 = self._save("new lora prompt", category="lora-manager")
+        self._link_image(pid2, "/cache/new.jpg")
+
+        results = self.db.search_prompts(category="lora-manager")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["text"], "new lora prompt")
+
+    def test_hash_dedup_prevents_duplicates(self):
+        """Verify hash-based dedup works for LoRA prompts."""
+        text = "duplicate lora prompt"
+        h = generate_prompt_hash(text)
+
+        self._save(text, category="lora-manager")
+        existing = self.db.get_prompt_by_hash(h)
+        self.assertIsNotNone(existing)
+
+    def test_link_multiple_images_to_lora_prompt(self):
+        """LoRA prompts can have multiple preview images."""
+        pid = self._save("multi-image lora", category="lora-manager")
+        self._link_image(pid, "/cache/lora/img1.jpg")
+        self._link_image(pid, "/cache/lora/img2.jpg")
+        self._link_image(pid, "/cache/lora/img3.jpg")
+
+        images = self.db.get_prompt_images(pid)
+        self.assertEqual(len(images), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_lora_utils.py b/tests/test_lora_utils.py
new file mode 100644
index 0000000..839f118
--- /dev/null
+++ b/tests/test_lora_utils.py
@@ -0,0 +1,316 @@
+"""
+Unit tests for LoRA Manager integration utilities.
+
+Tests metadata parsing, trigger word extraction, image URL extraction,
+directory detection, TriggerWordCache, and image download logic.
+"""
+
+import json
+import os
+import sys
+import tempfile
+import threading
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from py.lora_utils import (
+    TriggerWordCache,
+    get_civitai_image_urls,
+    get_example_prompt_from_metadata,
+    get_lora_image_cache_dir,
+    get_trigger_words_from_metadata,
+    read_lora_metadata,
+)
+
+# ── Sample metadata fixtures ───────────────────────────────────────────
+
+
+def _make_metadata(
+    trained_words=None,
+    images=None,
+    model_name="test_lora",
+    file_name="test.safetensors",
+):
+    """Build a realistic LoRA metadata dict for testing."""
+    meta = {"file_name": file_name}
+    civitai = {}
+    if trained_words is not None:
+        civitai["trainedWords"] = trained_words
+    if images is not None:
+        civitai["images"] = images
+    if model_name:
+        civitai["model"] = {"name": model_name}
+    if civitai:
+        meta["civitai"] = civitai
+    return meta
+
+
+# ── Pure function tests (no mocking) ──────────────────────────────────
+
+
+class TestGetTriggerWords(unittest.TestCase):
+    """Test get_trigger_words_from_metadata — pure dict extraction."""
+
+    def test_extracts_words(self):
+        meta = _make_metadata(trained_words=["word1", "word2", "word3"])
+        self.assertEqual(
+            get_trigger_words_from_metadata(meta), ["word1", "word2", "word3"]
+        )
+
+    def test_strips_whitespace(self):
+        meta = _make_metadata(trained_words=["  padded  ", "\ttabbed\t"])
+        self.assertEqual(get_trigger_words_from_metadata(meta), ["padded", "tabbed"])
+
+    def test_filters_empty_strings(self):
+        meta = _make_metadata(trained_words=["valid", "", "  ", "also_valid"])
+        self.assertEqual(get_trigger_words_from_metadata(meta), ["valid", "also_valid"])
+
+    def test_no_civitai_key(self):
+        self.assertEqual(get_trigger_words_from_metadata({}), [])
+
+    def test_no_trained_words(self):
+        meta = _make_metadata()
+        self.assertEqual(get_trigger_words_from_metadata(meta), [])
+
+    def test_trained_words_not_list(self):
+        meta = {"civitai": {"trainedWords": "not a list"}}
+        self.assertEqual(get_trigger_words_from_metadata(meta), [])
+
+    def test_non_string_items_filtered(self):
+        meta = _make_metadata(trained_words=["valid", 123, None, "also_valid"])
+        self.assertEqual(get_trigger_words_from_metadata(meta), ["valid", "also_valid"])
+
+
+class TestGetExamplePrompt(unittest.TestCase):
+    """Test get_example_prompt_from_metadata — extracts first usable prompt."""
+
+    def test_extracts_first_prompt(self):
+        images = [
+            {"meta": {"prompt": "a beautiful landscape"}},
+            {"meta": {"prompt": "second prompt"}},
+        ]
+        meta = _make_metadata(images=images)
+        self.assertEqual(
+            get_example_prompt_from_metadata(meta), "a beautiful landscape"
+        )
+
+    def test_skips_empty_prompts(self):
+        images = [
+            {"meta": {"prompt": ""}},
+            {"meta": {"prompt": "   "}},
+            {"meta": {"prompt": "valid prompt"}},
+        ]
+        meta = _make_metadata(images=images)
+        self.assertEqual(get_example_prompt_from_metadata(meta), "valid prompt")
+
+    def test_no_images(self):
+        meta = _make_metadata(images=[])
+        self.assertIsNone(get_example_prompt_from_metadata(meta))
+
+    def test_no_civitai(self):
+        self.assertIsNone(get_example_prompt_from_metadata({}))
+
+    def test_images_without_meta(self):
+        images = [{"url": "http://example.com/img.jpg"}]
+        meta = _make_metadata(images=images)
+        self.assertIsNone(get_example_prompt_from_metadata(meta))
+
+    def test_meta_without_prompt(self):
+        images = [{"meta": {"seed": 12345}}]
+        meta = _make_metadata(images=images)
+        self.assertIsNone(get_example_prompt_from_metadata(meta))
+
+    def test_non_dict_images_skipped(self):
+        images = ["not a dict", None, {"meta": {"prompt": "found it"}}]
+        meta = _make_metadata(images=images)
+        self.assertEqual(get_example_prompt_from_metadata(meta), "found it")
+
+    def test_non_string_prompt_skipped(self):
+        images = [{"meta": {"prompt": 12345}}, {"meta": {"prompt": "real prompt"}}]
+        meta = _make_metadata(images=images)
+        self.assertEqual(get_example_prompt_from_metadata(meta), "real prompt")
+
+
+class TestGetCivitaiImageUrls(unittest.TestCase):
+    """Test get_civitai_image_urls — extracts image URLs from metadata."""
+
+    def test_extracts_urls(self):
+        images = [
+            {"url": "https://civitai.com/img1.jpg"},
+            {"url": "https://civitai.com/img2.jpg"},
+        ]
+        meta = _make_metadata(images=images)
+        urls = get_civitai_image_urls(meta)
+        self.assertEqual(len(urls), 2)
+        self.assertIn("https://civitai.com/img1.jpg", urls)
+
+    def test_filters_empty_urls(self):
+        images = [{"url": ""}, {"url": "https://civitai.com/valid.jpg"}]
+        meta = _make_metadata(images=images)
+        urls = get_civitai_image_urls(meta)
+        self.assertEqual(urls, ["https://civitai.com/valid.jpg"])
+
+    def test_no_images(self):
+        meta = _make_metadata(images=[])
+        self.assertEqual(get_civitai_image_urls(meta), [])
+
+    def test_no_civitai(self):
+        self.assertEqual(get_civitai_image_urls({}), [])
+
+    def test_images_without_url_key(self):
+        images = [{"id": 1}, {"url": "https://civitai.com/valid.jpg"}]
+        meta = _make_metadata(images=images)
+        urls = get_civitai_image_urls(meta)
+        self.assertEqual(urls, ["https://civitai.com/valid.jpg"])
+
+    def test_non_dict_images_skipped(self):
+        images = [None, "bad", {"url": "https://civitai.com/valid.jpg"}]
+        meta = _make_metadata(images=images)
+        urls = get_civitai_image_urls(meta)
+        self.assertEqual(urls, ["https://civitai.com/valid.jpg"])
+
+
+# ── Filesystem-dependent tests ────────────────────────────────────────
+
+
+class TestReadLoraMetadata(unittest.TestCase):
+    """Test read_lora_metadata — file I/O with JSON parsing."""
+
+    def test_reads_valid_json(self):
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".metadata.json", delete=False
+        ) as f:
+            json.dump({"civitai": {"trainedWords": ["test"]}}, f)
+            f.flush()
+            path = Path(f.name)
+        try:
+            result = read_lora_metadata(path)
+            self.assertIsNotNone(result)
+            self.assertEqual(result["civitai"]["trainedWords"], ["test"])
+        finally:
+            os.unlink(path)
+
+    def test_returns_none_for_invalid_json(self):
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".metadata.json", delete=False
+        ) as f:
+            f.write("not valid json {{{")
+            f.flush()
+            path = Path(f.name)
+        try:
+            result = read_lora_metadata(path)
+            self.assertIsNone(result)
+        finally:
+            os.unlink(path)
+
+    def test_returns_none_for_missing_file(self):
+        result = read_lora_metadata(Path("/nonexistent/file.metadata.json"))
+        self.assertIsNone(result)
+
+
+class TestGetLoraImageCacheDir(unittest.TestCase):
+    """Test get_lora_image_cache_dir — returns and creates cache path."""
+
+    def test_returns_path(self):
+        cache_dir = get_lora_image_cache_dir()
+        self.assertIsInstance(cache_dir, Path)
+        self.assertTrue(str(cache_dir).endswith("data/lora_images"))
+
+    def test_directory_exists(self):
+        cache_dir = get_lora_image_cache_dir()
+        self.assertTrue(cache_dir.is_dir())
+
+
+# ── TriggerWordCache tests ────────────────────────────────────────────
+
+
+class TestTriggerWordCache(unittest.TestCase):
+    """Test TriggerWordCache — thread-safe trigger word lookup."""
+
+    def setUp(self):
+        self.cache = TriggerWordCache()
+
+    def test_initial_state(self):
+        self.assertFalse(self.cache.is_loaded)
+        self.assertEqual(self.cache.get_trigger_words("anything"), [])
+
+    def test_load_from_temp_directory(self):
+        """Create temp metadata files and verify cache loads them."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a metadata file
+            meta = {
+                "file_name": "my_lora.safetensors",
+                "civitai": {"trainedWords": ["trigger1", "trigger2"]},
+            }
+            meta_path = Path(tmpdir) / "my_lora.safetensors.metadata.json"
+            meta_path.write_text(json.dumps(meta))
+
+            # Patch find_lora_directories to return our temp dir
+            with patch("py.lora_utils.find_lora_directories", return_value=[tmpdir]):
+                count = self.cache.load(tmpdir)
+
+            self.assertTrue(self.cache.is_loaded)
+            # Cache keys by both file_name stem and metadata filename stem
+            self.assertGreaterEqual(count, 1)
+            self.assertEqual(
+                self.cache.get_trigger_words("my_lora"), ["trigger1", "trigger2"]
+            )
+
+    def test_case_insensitive_lookup(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            meta = {
+                "file_name": "MyLoRA.safetensors",
+                "civitai": {"trainedWords": ["word1"]},
+            }
+            (Path(tmpdir) / "MyLoRA.safetensors.metadata.json").write_text(
+                json.dumps(meta)
+            )
+
+            with patch("py.lora_utils.find_lora_directories", return_value=[tmpdir]):
+                self.cache.load(tmpdir)
+
+            self.assertEqual(self.cache.get_trigger_words("mylora"), ["word1"])
+            self.assertEqual(self.cache.get_trigger_words("MYLORA"), ["word1"])
+
+    def test_clear(self):
+        # Manually set cache state
+        self.cache._cache = {"test": ["word"]}
+        self.cache._loaded = True
+
+        self.cache.clear()
+        self.assertFalse(self.cache.is_loaded)
+        self.assertEqual(self.cache.get_trigger_words("test"), [])
+
+    def test_unknown_lora_returns_empty(self):
+        self.cache._cache = {"known": ["word"]}
+        self.cache._loaded = True
+        self.assertEqual(self.cache.get_trigger_words("unknown"), [])
+
+    def test_thread_safety(self):
+        """Verify concurrent access doesn't raise."""
+        self.cache._cache = {"lora": ["word"]}
+        self.cache._loaded = True
+
+        errors = []
+
+        def reader():
+            try:
+                for _ in range(100):
+                    self.cache.get_trigger_words("lora")
+            except Exception as e:
+                errors.append(e)
+
+        threads = [threading.Thread(target=reader) for _ in range(10)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        self.assertEqual(errors, [])
+
+
+if __name__ == "__main__":
+    unittest.main()

From 051fa9ab683d81a999d15f2dc3788ae5357c2a0e Mon Sep 17 00:00:00 2001
From: Vito Sansevero <vito.sansevero@gmail.com>
Date: Fri, 3 Apr 2026 18:23:28 -0700
Subject: [PATCH 24/24] fix: remove unused MagicMock import in test_lora_utils
 (#52)

---
 tests/test_lora_utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_lora_utils.py b/tests/test_lora_utils.py
index 839f118..3f355c3 100644
--- a/tests/test_lora_utils.py
+++ b/tests/test_lora_utils.py
@@ -12,7 +12,7 @@
 import threading
 import unittest
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))