From 943bc9a114e94c5069b094b64bb10e4f083d2e16 Mon Sep 17 00:00:00 2001 From: tduhamel42 Date: Thu, 6 Nov 2025 11:07:50 +0100 Subject: [PATCH] Release v0.7.3 - Android workflows, LiteLLM integration, ARM64 support (#32) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * ci: add worker validation and Docker build checks Add automated validation to prevent worker-related issues: **Worker Validation Script:** - New script: .github/scripts/validate-workers.sh - Validates all workers in docker-compose.yml exist - Checks required files: Dockerfile, requirements.txt, worker.py - Verifies files are tracked by git (not gitignored) - Detects gitignore issues that could hide workers **CI Workflow Updates:** - Added validate-workers job (runs on every PR) - Added build-workers job (runs if workers/ modified) - Uses Docker Buildx for caching - Validates Docker images build successfully - Updated test-summary to check validation results **PR Template:** - New pull request template with comprehensive checklist - Specific section for worker-related changes - Reminds contributors to validate worker files - Includes documentation and changelog reminders These checks would have caught the secrets worker gitignore issue. Implements Phase 1 improvements from CI/CD quality assessment. * fix: add dev branch to test workflow triggers The test workflow was configured for 'develop' but the actual branch is named 'dev'. This caused tests not to run on PRs to dev branch. Now tests will run on: - PRs to: main, master, dev, develop - Pushes to: main, master, dev, develop, feature/** * fix: properly detect worker file changes in CI The previous condition used invalid GitHub context field. Now uses git diff to properly detect changes to workers/ or docker-compose.yml. Behavior: - Job always runs the check step - Detects if workers/ or docker-compose.yml modified - Only builds Docker images if workers actually changed - Shows clear skip message when no worker changes detected * feat: Add Python SAST workflow with three security analysis tools Implements Issue #5 - Python SAST workflow that combines: - Dependency scanning (pip-audit) for CVE detection - Security linting (Bandit) for vulnerability patterns - Type checking (Mypy) for type safety issues ## Changes **New Modules:** - `DependencyScanner`: Scans Python dependencies for known CVEs using pip-audit - `BanditAnalyzer`: Analyzes Python code for security issues using Bandit - `MypyAnalyzer`: Checks Python code for type safety issues using Mypy **New Workflow:** - `python_sast`: Temporal workflow that orchestrates all three SAST tools - Runs tools in parallel for fast feedback (3-5 min vs hours for fuzzing) - Generates unified SARIF report with findings from all tools - Supports configurable severity/confidence thresholds **Updates:** - Added SAST dependencies to Python worker (bandit, pip-audit, mypy) - Updated module __init__.py files to export new analyzers - Added type_errors.py test file to vulnerable_app for Mypy validation ## Testing Workflow tested successfully on vulnerable_app: - ✅ Bandit: Detected 9 security issues (command injection, unsafe functions) - ✅ Mypy: Detected 5 type errors - ✅ DependencyScanner: Ran successfully (no CVEs in test dependencies) - ✅ SARIF export: Generated valid SARIF with 14 total findings * fix: Remove unused imports to pass linter * fix: resolve live monitoring bug, remove deprecated parameters, and auto-start Python worker - Fix live monitoring style error by calling _live_monitor() helper directly - Remove default_parameters duplication from 10 workflow metadata files - Remove deprecated volume_mode parameter from 26 files across CLI, SDK, backend, and docs - Configure Python worker to start automatically with docker compose up - Clean up constants, validation, completion, and example files Fixes # - Live monitoring now works correctly with --live flag - Workflow metadata follows JSON Schema standard - Cleaner codebase without deprecated volume_mode - Python worker (most commonly used) starts by default * fix: resolve linter errors and optimize CI worker builds - Remove unused Literal import from backend findings model - Remove unnecessary f-string prefixes in CLI findings command - Optimize GitHub Actions to build only modified workers - Detect specific worker changes (python, secrets, rust, android, ossfuzz) - Build only changed workers instead of all 5 - Build all workers if docker-compose.yml changes - Significantly reduces CI build time * feat: Add Android static analysis workflow with Jadx, OpenGrep, and MobSF Comprehensive Android security testing workflow converted from Prefect to Temporal architecture: Modules (3): - JadxDecompiler: APK to Java source code decompilation - OpenGrepAndroid: Static analysis with Android-specific security rules - MobSFScanner: Comprehensive mobile security framework integration Custom Rules (13): - clipboard-sensitive-data, hardcoded-secrets, insecure-data-storage - insecure-deeplink, insecure-logging, intent-redirection - sensitive_data_sharedPreferences, sqlite-injection - vulnerable-activity, vulnerable-content-provider, vulnerable-service - webview-javascript-enabled, webview-load-arbitrary-url Workflow: - 6-phase Temporal workflow: download → Jadx → OpenGrep → MobSF → SARIF → upload - 4 activities: decompile_with_jadx, scan_with_opengrep, scan_with_mobsf, generate_android_sarif - SARIF output combining findings from all security tools Docker Worker: - ARM64 Mac compatibility via amd64 platform emulation - Pre-installed: Android SDK, Jadx 1.4.7, OpenGrep 1.45.0, MobSF 3.9.7 - MobSF runs as background service with API key auto-generation - Added aiohttp for async HTTP communication Test APKs: - BeetleBug.apk and shopnest.apk for workflow validation * fix(android): correct activity names and MobSF API key generation - Fix activity names in workflow.py (get_target, upload_results, cleanup_cache) - Fix MobSF API key generation in Dockerfile startup script (cut delimiter) - Update activity parameter signatures to match actual implementations - Workflow now executes successfully with Jadx and OpenGrep * feat: add platform-aware worker architecture with ARM64 support Implement platform-specific Dockerfile selection and graceful tool degradation to support both x86_64 and ARM64 (Apple Silicon) platforms. **Backend Changes:** - Add system info API endpoint (/system/info) exposing host filesystem paths - Add FUZZFORGE_HOST_ROOT environment variable to backend service - Add graceful degradation in MobSF activity for ARM64 platforms **CLI Changes:** - Implement multi-strategy path resolution (backend API, .fuzzforge marker, env var) - Add platform detection (linux/amd64 vs linux/arm64) - Add worker metadata.yaml reading for platform capabilities - Auto-select appropriate Dockerfile based on detected platform - Pass platform-specific env vars to docker-compose **Worker Changes:** - Create workers/android/metadata.yaml defining platform capabilities - Rename Dockerfile -> Dockerfile.amd64 (full toolchain with MobSF) - Create Dockerfile.arm64 (excludes MobSF due to Rosetta 2 incompatibility) - Update docker-compose.yml to use ${ANDROID_DOCKERFILE} variable **Workflow Changes:** - Handle MobSF "skipped" status gracefully in workflow - Log clear warnings when tools are unavailable on platform **Key Features:** - Automatic platform detection and Dockerfile selection - Graceful degradation when tools unavailable (MobSF on ARM64) - Works from any directory (backend API provides paths) - Manual override via environment variables - Clear user feedback about platform and selected Dockerfile **Benefits:** - Android workflow now works on Apple Silicon Macs - No code changes needed for other workflows - Convention established for future platform-specific workers Closes: MobSF Rosetta 2 incompatibility issue Implements: Platform-aware worker architecture (Option B) * fix: make MobSFScanner import conditional for ARM64 compatibility - Add try-except block to conditionally import MobSFScanner in modules/android/__init__.py - Allows Android worker to start on ARM64 without MobSF dependencies (aiohttp) - MobSF activity gracefully skips on ARM64 with clear warning message - Remove workflow path detection logic (not needed - workflows receive directories) Platform-aware architecture fully functional on ARM64: - CLI detects ARM64 and selects Dockerfile.arm64 automatically - Worker builds and runs without MobSF on ARM64 - Jadx successfully decompiles APKs (4145 files from BeetleBug.apk) - OpenGrep finds security vulnerabilities (8 issues found) - MobSF gracefully skips with warning on ARM64 - Graceful degradation working as designed Tested with: ff workflow run android_static_analysis test_projects/android_test/ \ --wait --no-interactive apk_path=BeetleBug.apk decompile_apk=true Results: 8 security findings (1 ERROR, 7 WARNINGS) * docs: update CHANGELOG with Android workflow and ARM64 support Added [Unreleased] section documenting: - Android Static Analysis Workflow (Jadx, OpenGrep, MobSF) - Platform-Aware Worker Architecture with ARM64 support - Python SAST Workflow - CI/CD improvements and worker validation - CLI enhancements - Bug fixes and technical changes Fixed date typo: 2025-01-16 → 2025-10-16 * fix: resolve linter errors in Android modules - Remove unused imports from mobsf_scanner.py (asyncio, hashlib, json, Optional) - Remove unused variables from opengrep_android.py (start_col, end_col) - Remove duplicate Path import from workflow.py * ci: support multi-platform Dockerfiles in worker validation Updated worker validation script to accept both: - Single Dockerfile pattern (existing workers) - Multi-platform Dockerfile pattern (Dockerfile.amd64, Dockerfile.arm64, etc.) This enables platform-aware worker architectures like the Android worker which uses different Dockerfiles for x86_64 and ARM64 platforms. * Feature/litellm proxy (#27) * feat: seed governance config and responses routing * Add env-configurable timeout for proxy providers * Integrate LiteLLM OTEL collector and update docs * Make .env.litellm optional for LiteLLM proxy * Add LiteLLM proxy integration with model-agnostic virtual keys Changes: - Bootstrap generates 3 virtual keys with individual budgets (CLI: $100, Task-Agent: $25, Cognee: $50) - Task-agent loads config at runtime via entrypoint script to wait for bootstrap completion - All keys are model-agnostic by default (no LITELLM_DEFAULT_MODELS restrictions) - Bootstrap handles database/env mismatch after docker prune by deleting stale aliases - CLI and Cognee configured to use LiteLLM proxy with virtual keys - Added comprehensive documentation in volumes/env/README.md Technical details: - task-agent entrypoint waits for keys in .env file before starting uvicorn - Bootstrap creates/updates TASK_AGENT_API_KEY, COGNEE_API_KEY, and OPENAI_API_KEY - Removed hardcoded API keys from docker-compose.yml - All services route through http://localhost:10999 proxy * Fix CLI not loading virtual keys from global .env Project .env files with empty OPENAI_API_KEY values were overriding the global virtual keys. Updated _load_env_file_if_exists to only override with non-empty values. * Fix agent executor not passing API key to LiteLLM The agent was initializing LiteLlm without api_key or api_base, causing authentication errors when using the LiteLLM proxy. Now reads from OPENAI_API_KEY/LLM_API_KEY and LLM_ENDPOINT environment variables and passes them to LiteLlm constructor. * Auto-populate project .env with virtual key from global config When running 'ff init', the command now checks for a global volumes/env/.env file and automatically uses the OPENAI_API_KEY virtual key if found. This ensures projects work with LiteLLM proxy out of the box without manual key configuration. * docs: Update README with LiteLLM configuration instructions Add note about LITELLM_GEMINI_API_KEY configuration and clarify that OPENAI_API_KEY default value should not be changed as it's used for the LLM proxy. * Refactor workflow parameters to use JSON Schema defaults Consolidates parameter defaults into JSON Schema format, removing the separate default_parameters field. Adds extract_defaults_from_json_schema() helper to extract defaults from the standard schema structure. Updates LiteLLM proxy config to use LITELLM_OPENAI_API_KEY environment variable. * Remove .env.example from task_agent * Fix MDX syntax error in llm-proxy.md * fix: apply default parameters from metadata.yaml automatically Fixed TemporalManager.run_workflow() to correctly apply default parameter values from workflow metadata.yaml files when parameters are not provided by the caller. Previous behavior: - When workflow_params was empty {}, the condition `if workflow_params and 'parameters' in metadata` would fail - Parameters would not be extracted from schema, resulting in workflows receiving only target_id with no other parameters New behavior: - Removed the `workflow_params and` requirement from the condition - Now explicitly checks for defaults in parameter spec - Applies defaults from metadata.yaml automatically when param not provided - Workflows receive all parameters with proper fallback: provided value > metadata default > None This makes metadata.yaml the single source of truth for parameter defaults, removing the need for workflows to implement defensive default handling. Affected workflows: - llm_secret_detection (was failing with KeyError) - All other workflows now benefit from automatic default application Co-authored-by: tduhamel42 * fix: add default values to llm_analysis workflow parameters Resolves validation error where agent_url was None when not explicitly provided. The TemporalManager applies defaults from metadata.yaml, not from module input schemas, so all parameters need defaults in the workflow metadata. Changes: - Add default agent_url, llm_model (gpt-5-mini), llm_provider (openai) - Expand file_patterns to 45 comprehensive patterns covering code, configs, secrets, and Docker files - Increase default limits: max_files (10), max_file_size (100KB), timeout (90s) * refactor: replace .env.example with .env.template in documentation - Remove volumes/env/.env.example file - Update all documentation references to use .env.template instead - Update bootstrap script error message - Update .gitignore comment * feat(cli): add worker management commands with improved progress feedback Add comprehensive CLI commands for managing Temporal workers: - ff worker list - List workers with status and uptime - ff worker start - Start specific worker with optional rebuild - ff worker stop - Safely stop all workers without affecting core services Improvements: - Live progress display during worker startup with Rich Status spinner - Real-time elapsed time counter and container state updates - Health check status tracking (starting → unhealthy → healthy) - Helpful contextual hints at 10s, 30s, 60s intervals - Better timeout messages showing last known state Worker management enhancements: - Use 'docker compose' (space) instead of 'docker-compose' (hyphen) - Stop workers individually with 'docker stop' to avoid stopping core services - Platform detection and Dockerfile selection (ARM64/AMD64) Documentation: - Updated docker-setup.md with CLI commands as primary method - Created comprehensive cli-reference.md with all commands and examples - Added worker management best practices * fix: MobSF scanner now properly parses files dict structure MobSF returns 'files' as a dict (not list): {"filename": "line_numbers"} The parser was treating it as a list, causing zero findings to be extracted. Now properly iterates over the dict and creates one finding per affected file with correct line numbers and metadata (CWE, OWASP, MASVS, CVSS). Fixed in both code_analysis and behaviour sections. * chore: bump version to 0.7.3 * docs: fix broken documentation links in cli-reference * chore: add worker startup documentation and cleanup .gitignore - Add workflow-to-worker mapping tables across documentation - Update troubleshooting guide with worker requirements section - Enhance getting started guide with worker examples - Add quick reference to docker setup guide - Add WEEK_SUMMARY*.md pattern to .gitignore * docs: update CHANGELOG with missing versions and recent changes - Add Unreleased section for post-v0.7.3 documentation updates - Add v0.7.2 entry with bug fixes and worker improvements - Document that v0.7.1 was re-tagged as v0.7.2 - Fix v0.6.0 date to "Undocumented" (no tag exists) - Add version comparison links for easier navigation * chore: bump all package versions to 0.7.3 for consistency * Update GitHub link to fuzzforge_ai --------- Co-authored-by: Songbird99 <150154823+Songbird99@users.noreply.github.com> Co-authored-by: Songbird --- .github/pull_request_template.md | 79 ++ .github/scripts/validate-workers.sh | 127 ++++ .github/workflows/test.yml | 99 ++- .gitignore | 10 +- CHANGELOG.md | 125 +++- README.md | 18 +- ai/agents/task_agent/.env.example | 10 - ai/agents/task_agent/Dockerfile | 5 + ai/agents/task_agent/README.md | 32 +- ai/agents/task_agent/docker-entrypoint.sh | 31 + ai/agents/task_agent/litellm_agent/config.py | 19 +- ai/agents/task_agent/litellm_agent/state.py | 170 ++++- ai/proxy/README.md | 5 + ai/pyproject.toml | 2 +- ai/src/fuzzforge_ai/__init__.py | 2 +- ai/src/fuzzforge_ai/agent_executor.py | 27 +- ai/src/fuzzforge_ai/cognee_service.py | 40 +- backend/mcp-config.json | 1 - backend/pyproject.toml | 2 +- backend/src/api/system.py | 47 ++ backend/src/api/workflows.py | 49 +- backend/src/main.py | 19 +- backend/src/models/findings.py | 6 +- backend/src/temporal/manager.py | 20 +- backend/toolbox/modules/analyzer/__init__.py | 4 +- .../modules/analyzer/bandit_analyzer.py | 328 +++++++++ .../toolbox/modules/analyzer/mypy_analyzer.py | 269 +++++++ backend/toolbox/modules/android/__init__.py | 31 + .../clipboard-sensitive-data.yaml | 15 + .../custom_rules/hardcoded-secrets.yaml | 23 + .../custom_rules/insecure-data-storage.yaml | 18 + .../custom_rules/insecure-deeplink.yaml | 16 + .../custom_rules/insecure-logging.yaml | 21 + .../custom_rules/intent-redirection.yaml | 15 + .../sensitive_data_sharedPreferences.yaml | 18 + .../custom_rules/sqlite-injection.yaml | 21 + .../custom_rules/vulnerable-activity.yaml | 16 + .../vulnerable-content-provider.yaml | 16 + .../custom_rules/vulnerable-service.yaml | 16 + .../webview-javascript-enabled.yaml | 16 + .../webview-load-arbitrary-url.yaml | 16 + .../modules/android/jadx_decompiler.py | 270 +++++++ .../toolbox/modules/android/mobsf_scanner.py | 437 +++++++++++ .../modules/android/opengrep_android.py | 440 +++++++++++ backend/toolbox/modules/scanner/__init__.py | 3 +- .../modules/scanner/dependency_scanner.py | 302 ++++++++ .../secret_detection/llm_secret_detector.py | 19 +- .../android_static_analysis/__init__.py | 35 + .../android_static_analysis/activities.py | 213 ++++++ .../android_static_analysis/metadata.yaml | 172 +++++ .../android_static_analysis/workflow.py | 289 ++++++++ .../workflows/atheris_fuzzing/metadata.yaml | 5 - .../workflows/cargo_fuzzing/metadata.yaml | 6 - .../gitleaks_detection/metadata.yaml | 8 - .../workflows/llm_analysis/metadata.yaml | 60 +- .../llm_secret_detection/metadata.yaml | 44 +- .../llm_secret_detection/workflow.py | 3 + .../workflows/ossfuzz_campaign/metadata.yaml | 7 - .../toolbox/workflows/python_sast/__init__.py | 10 + .../workflows/python_sast/activities.py | 191 +++++ .../workflows/python_sast/metadata.yaml | 110 +++ .../toolbox/workflows/python_sast/workflow.py | 265 +++++++ .../security_assessment/metadata.yaml | 5 - .../trufflehog_detection/metadata.yaml | 7 - cli/pyproject.toml | 2 +- cli/src/fuzzforge_cli/__init__.py | 2 +- cli/src/fuzzforge_cli/commands/__init__.py | 3 + cli/src/fuzzforge_cli/commands/findings.py | 8 +- cli/src/fuzzforge_cli/commands/init.py | 39 +- cli/src/fuzzforge_cli/commands/worker.py | 225 ++++++ .../fuzzforge_cli/commands/workflow_exec.py | 20 +- cli/src/fuzzforge_cli/completion.py | 12 - cli/src/fuzzforge_cli/config.py | 95 ++- cli/src/fuzzforge_cli/constants.py | 4 - cli/src/fuzzforge_cli/fuzzy.py | 2 - cli/src/fuzzforge_cli/main.py | 15 +- cli/src/fuzzforge_cli/validation.py | 11 +- cli/src/fuzzforge_cli/worker_manager.py | 470 ++++++++++-- docker-compose.yml | 115 ++- docker/scripts/bootstrap_llm_proxy.py | 636 ++++++++++++++++ ...5-01-16-v0.7.0-temporal-workers-release.md | 2 +- docs/docs/how-to/docker-setup.md | 56 +- docs/docs/how-to/litellm-hot-swap.md | 179 +++++ docs/docs/how-to/llm-proxy.md | 194 +++++ docs/docs/how-to/troubleshooting.md | 42 +- docs/docs/reference/cli-reference.md | 616 ++++++++++++++++ docs/docs/tutorial/getting-started.md | 38 +- docs/docusaurus.config.ts | 4 +- docs/index.md | 2 +- pyproject.toml | 2 +- sdk/examples/basic_workflow.py | 3 - sdk/examples/batch_analysis.py | 5 - sdk/examples/fuzzing_monitor.py | 1 - sdk/examples/save_findings_demo.py | 1 - sdk/pyproject.toml | 2 +- sdk/src/fuzzforge_sdk/__init__.py | 2 +- sdk/src/fuzzforge_sdk/client.py | 2 - sdk/src/fuzzforge_sdk/testing.py | 2 - src/fuzzforge/__init__.py | 2 +- test_projects/android_test/BeetleBug.apk | Bin 0 -> 9429128 bytes test_projects/android_test/shopnest.apk | Bin 0 -> 12329881 bytes .../vulnerable_app/findings-security.json | 695 ++++++++++++++++++ test_projects/vulnerable_app/type_errors.py | 62 ++ volumes/env/.env.example | 17 - volumes/env/.env.template | 65 ++ volumes/env/README.md | 95 ++- volumes/litellm/proxy_config.yaml | 26 + volumes/otel/collector-config.yaml | 25 + workers/android/Dockerfile.amd64 | 148 ++++ .../android/{Dockerfile => Dockerfile.arm64} | 30 +- workers/android/metadata.yaml | 42 ++ workers/python/requirements.txt | 5 + 112 files changed, 8358 insertions(+), 371 deletions(-) create mode 100644 .github/pull_request_template.md create mode 100755 .github/scripts/validate-workers.sh delete mode 100644 ai/agents/task_agent/.env.example create mode 100644 ai/agents/task_agent/docker-entrypoint.sh create mode 100644 ai/proxy/README.md create mode 100644 backend/src/api/system.py create mode 100644 backend/toolbox/modules/analyzer/bandit_analyzer.py create mode 100644 backend/toolbox/modules/analyzer/mypy_analyzer.py create mode 100644 backend/toolbox/modules/android/__init__.py create mode 100644 backend/toolbox/modules/android/custom_rules/clipboard-sensitive-data.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/hardcoded-secrets.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/insecure-data-storage.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/insecure-deeplink.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/insecure-logging.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/intent-redirection.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/sensitive_data_sharedPreferences.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/sqlite-injection.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/vulnerable-activity.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/vulnerable-content-provider.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/vulnerable-service.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/webview-javascript-enabled.yaml create mode 100644 backend/toolbox/modules/android/custom_rules/webview-load-arbitrary-url.yaml create mode 100644 backend/toolbox/modules/android/jadx_decompiler.py create mode 100644 backend/toolbox/modules/android/mobsf_scanner.py create mode 100644 backend/toolbox/modules/android/opengrep_android.py create mode 100644 backend/toolbox/modules/scanner/dependency_scanner.py create mode 100644 backend/toolbox/workflows/android_static_analysis/__init__.py create mode 100644 backend/toolbox/workflows/android_static_analysis/activities.py create mode 100644 backend/toolbox/workflows/android_static_analysis/metadata.yaml create mode 100644 backend/toolbox/workflows/android_static_analysis/workflow.py create mode 100644 backend/toolbox/workflows/python_sast/__init__.py create mode 100644 backend/toolbox/workflows/python_sast/activities.py create mode 100644 backend/toolbox/workflows/python_sast/metadata.yaml create mode 100644 backend/toolbox/workflows/python_sast/workflow.py create mode 100644 cli/src/fuzzforge_cli/commands/worker.py create mode 100644 docker/scripts/bootstrap_llm_proxy.py create mode 100644 docs/docs/how-to/litellm-hot-swap.md create mode 100644 docs/docs/how-to/llm-proxy.md create mode 100644 docs/docs/reference/cli-reference.md create mode 100644 test_projects/android_test/BeetleBug.apk create mode 100644 test_projects/android_test/shopnest.apk create mode 100644 test_projects/vulnerable_app/findings-security.json create mode 100644 test_projects/vulnerable_app/type_errors.py delete mode 100644 volumes/env/.env.example create mode 100644 volumes/env/.env.template create mode 100644 volumes/litellm/proxy_config.yaml create mode 100644 volumes/otel/collector-config.yaml create mode 100644 workers/android/Dockerfile.amd64 rename workers/android/{Dockerfile => Dockerfile.arm64} (73%) create mode 100644 workers/android/metadata.yaml diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000..04ece70 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,79 @@ +## Description + + + +## Type of Change + + + +- [ ] 🐛 Bug fix (non-breaking change which fixes an issue) +- [ ] ✨ New feature (non-breaking change which adds functionality) +- [ ] 💥 Breaking change (fix or feature that would cause existing functionality to not work as expected) +- [ ] 📝 Documentation update +- [ ] 🔧 Configuration change +- [ ] ♻️ Refactoring (no functional changes) +- [ ] 🎨 Style/formatting changes +- [ ] ✅ Test additions or updates + +## Related Issues + + + + +## Changes Made + + + +- +- +- + +## Testing + + + +### Tested Locally + +- [ ] All tests pass (`pytest`, `uv build`, etc.) +- [ ] Linting passes (`ruff check`) +- [ ] Code builds successfully + +### Worker Changes (if applicable) + +- [ ] Docker images build successfully (`docker compose build`) +- [ ] Worker containers start correctly +- [ ] Tested with actual workflow execution + +### Documentation + +- [ ] Documentation updated (if needed) +- [ ] README updated (if needed) +- [ ] CHANGELOG.md updated (if user-facing changes) + +## Pre-Merge Checklist + + + +- [ ] My code follows the project's coding standards +- [ ] I have performed a self-review of my code +- [ ] I have commented my code, particularly in hard-to-understand areas +- [ ] I have made corresponding changes to the documentation +- [ ] My changes generate no new warnings +- [ ] I have added tests that prove my fix is effective or that my feature works +- [ ] New and existing unit tests pass locally with my changes +- [ ] Any dependent changes have been merged and published + +### Worker-Specific Checks (if workers/ modified) + +- [ ] All worker files properly tracked by git (not gitignored) +- [ ] Worker validation script passes (`.github/scripts/validate-workers.sh`) +- [ ] Docker images build without errors +- [ ] Worker configuration updated in `docker-compose.yml` (if needed) + +## Screenshots (if applicable) + + + +## Additional Notes + + diff --git a/.github/scripts/validate-workers.sh b/.github/scripts/validate-workers.sh new file mode 100755 index 0000000..6b2c5f6 --- /dev/null +++ b/.github/scripts/validate-workers.sh @@ -0,0 +1,127 @@ +#!/bin/bash +# Worker Validation Script +# Ensures all workers defined in docker-compose.yml exist in the repository +# and are properly tracked by git. + +set -e + +echo "🔍 Validating worker completeness..." + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' # No Color + +ERRORS=0 +WARNINGS=0 + +# Extract worker service names from docker-compose.yml +echo "" +echo "📋 Checking workers defined in docker-compose.yml..." +WORKERS=$(grep -E "^\s+worker-" docker-compose.yml | grep -v "#" | cut -d: -f1 | tr -d ' ' | sort -u) + +if [ -z "$WORKERS" ]; then + echo -e "${RED}❌ No workers found in docker-compose.yml${NC}" + exit 1 +fi + +echo "Found workers:" +for worker in $WORKERS; do + echo " - $worker" +done + +# Check each worker +echo "" +echo "🔎 Validating worker files..." +for worker in $WORKERS; do + WORKER_DIR="workers/${worker#worker-}" + + echo "" + echo "Checking $worker ($WORKER_DIR)..." + + # Check if directory exists + if [ ! -d "$WORKER_DIR" ]; then + echo -e "${RED} ❌ Directory not found: $WORKER_DIR${NC}" + ERRORS=$((ERRORS + 1)) + continue + fi + + # Check Dockerfile (single file or multi-platform pattern) + if [ -f "$WORKER_DIR/Dockerfile" ]; then + # Single Dockerfile + if ! git ls-files --error-unmatch "$WORKER_DIR/Dockerfile" &> /dev/null; then + echo -e "${RED} ❌ File not tracked by git: $WORKER_DIR/Dockerfile${NC}" + echo -e "${YELLOW} Check .gitignore patterns!${NC}" + ERRORS=$((ERRORS + 1)) + else + echo -e "${GREEN} ✓ Dockerfile (tracked)${NC}" + fi + elif compgen -G "$WORKER_DIR/Dockerfile.*" > /dev/null; then + # Multi-platform Dockerfiles (e.g., Dockerfile.amd64, Dockerfile.arm64) + PLATFORM_DOCKERFILES=$(ls "$WORKER_DIR"/Dockerfile.* 2>/dev/null) + DOCKERFILE_FOUND=false + for dockerfile in $PLATFORM_DOCKERFILES; do + if git ls-files --error-unmatch "$dockerfile" &> /dev/null; then + echo -e "${GREEN} ✓ $(basename "$dockerfile") (tracked)${NC}" + DOCKERFILE_FOUND=true + else + echo -e "${RED} ❌ File not tracked by git: $dockerfile${NC}" + ERRORS=$((ERRORS + 1)) + fi + done + if [ "$DOCKERFILE_FOUND" = false ]; then + echo -e "${RED} ❌ No platform-specific Dockerfiles found${NC}" + ERRORS=$((ERRORS + 1)) + fi + else + echo -e "${RED} ❌ Missing Dockerfile or Dockerfile.* files${NC}" + ERRORS=$((ERRORS + 1)) + fi + + # Check other required files + REQUIRED_FILES=("requirements.txt" "worker.py") + for file in "${REQUIRED_FILES[@]}"; do + FILE_PATH="$WORKER_DIR/$file" + + if [ ! -f "$FILE_PATH" ]; then + echo -e "${RED} ❌ Missing file: $FILE_PATH${NC}" + ERRORS=$((ERRORS + 1)) + else + # Check if file is tracked by git + if ! git ls-files --error-unmatch "$FILE_PATH" &> /dev/null; then + echo -e "${RED} ❌ File not tracked by git: $FILE_PATH${NC}" + echo -e "${YELLOW} Check .gitignore patterns!${NC}" + ERRORS=$((ERRORS + 1)) + else + echo -e "${GREEN} ✓ $file (tracked)${NC}" + fi + fi + done +done + +# Check for any ignored worker files +echo "" +echo "🚫 Checking for gitignored worker files..." +IGNORED_FILES=$(git check-ignore workers/*/* 2>/dev/null || true) +if [ -n "$IGNORED_FILES" ]; then + echo -e "${YELLOW}⚠️ Warning: Some worker files are being ignored:${NC}" + echo "$IGNORED_FILES" | while read -r file; do + echo -e "${YELLOW} - $file${NC}" + done + WARNINGS=$((WARNINGS + 1)) +fi + +# Summary +echo "" +echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" +if [ $ERRORS -eq 0 ] && [ $WARNINGS -eq 0 ]; then + echo -e "${GREEN}✅ All workers validated successfully!${NC}" + exit 0 +elif [ $ERRORS -eq 0 ]; then + echo -e "${YELLOW}⚠️ Validation passed with $WARNINGS warning(s)${NC}" + exit 0 +else + echo -e "${RED}❌ Validation failed with $ERRORS error(s) and $WARNINGS warning(s)${NC}" + exit 1 +fi diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 03581ef..9f79b46 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,11 +2,100 @@ name: Tests on: push: - branches: [ main, master, develop, feature/** ] + branches: [ main, master, dev, develop, feature/** ] pull_request: - branches: [ main, master, develop ] + branches: [ main, master, dev, develop ] jobs: + validate-workers: + name: Validate Workers + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Run worker validation + run: | + chmod +x .github/scripts/validate-workers.sh + .github/scripts/validate-workers.sh + + build-workers: + name: Build Worker Docker Images + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 # Fetch all history for proper diff + + - name: Check which workers were modified + id: check-workers + run: | + if [ "${{ github.event_name }}" == "pull_request" ]; then + # For PRs, check changed files + CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD) + echo "Changed files:" + echo "$CHANGED_FILES" + else + # For direct pushes, check last commit + CHANGED_FILES=$(git diff --name-only HEAD~1 HEAD) + fi + + # Check if docker-compose.yml changed (build all workers) + if echo "$CHANGED_FILES" | grep -q "^docker-compose.yml"; then + echo "workers_to_build=worker-python worker-secrets worker-rust worker-android worker-ossfuzz" >> $GITHUB_OUTPUT + echo "workers_modified=true" >> $GITHUB_OUTPUT + echo "✅ docker-compose.yml modified - building all workers" + exit 0 + fi + + # Detect which specific workers changed + WORKERS_TO_BUILD="" + + if echo "$CHANGED_FILES" | grep -q "^workers/python/"; then + WORKERS_TO_BUILD="$WORKERS_TO_BUILD worker-python" + echo "✅ Python worker modified" + fi + + if echo "$CHANGED_FILES" | grep -q "^workers/secrets/"; then + WORKERS_TO_BUILD="$WORKERS_TO_BUILD worker-secrets" + echo "✅ Secrets worker modified" + fi + + if echo "$CHANGED_FILES" | grep -q "^workers/rust/"; then + WORKERS_TO_BUILD="$WORKERS_TO_BUILD worker-rust" + echo "✅ Rust worker modified" + fi + + if echo "$CHANGED_FILES" | grep -q "^workers/android/"; then + WORKERS_TO_BUILD="$WORKERS_TO_BUILD worker-android" + echo "✅ Android worker modified" + fi + + if echo "$CHANGED_FILES" | grep -q "^workers/ossfuzz/"; then + WORKERS_TO_BUILD="$WORKERS_TO_BUILD worker-ossfuzz" + echo "✅ OSS-Fuzz worker modified" + fi + + if [ -z "$WORKERS_TO_BUILD" ]; then + echo "workers_modified=false" >> $GITHUB_OUTPUT + echo "⏭️ No worker changes detected - skipping build" + else + echo "workers_to_build=$WORKERS_TO_BUILD" >> $GITHUB_OUTPUT + echo "workers_modified=true" >> $GITHUB_OUTPUT + echo "Building workers:$WORKERS_TO_BUILD" + fi + + - name: Set up Docker Buildx + if: steps.check-workers.outputs.workers_modified == 'true' + uses: docker/setup-buildx-action@v3 + + - name: Build worker images + if: steps.check-workers.outputs.workers_modified == 'true' + run: | + WORKERS="${{ steps.check-workers.outputs.workers_to_build }}" + echo "Building worker Docker images: $WORKERS" + docker compose build $WORKERS --no-cache + continue-on-error: false + lint: name: Lint runs-on: ubuntu-latest @@ -143,11 +232,15 @@ jobs: test-summary: name: Test Summary runs-on: ubuntu-latest - needs: [lint, unit-tests] + needs: [validate-workers, lint, unit-tests] if: always() steps: - name: Check test results run: | + if [ "${{ needs.validate-workers.result }}" != "success" ]; then + echo "Worker validation failed" + exit 1 + fi if [ "${{ needs.unit-tests.result }}" != "success" ]; then echo "Unit tests failed" exit 1 diff --git a/.gitignore b/.gitignore index da918ac..a8d6e44 100644 --- a/.gitignore +++ b/.gitignore @@ -188,6 +188,10 @@ logs/ # Docker volume configs (keep .env.example but ignore actual .env) volumes/env/.env +# Vendored proxy sources (kept locally for reference) +ai/proxy/bifrost/ +ai/proxy/litellm/ + # Test project databases and configurations test_projects/*/.fuzzforge/ test_projects/*/findings.db* @@ -304,4 +308,8 @@ test_projects/*/.npmrc test_projects/*/.git-credentials test_projects/*/credentials.* test_projects/*/api_keys.* -test_projects/*/ci-*.sh \ No newline at end of file +test_projects/*/ci-*.sh + +# -------------------- Internal Documentation -------------------- +# Weekly summaries and temporary project documentation +WEEK_SUMMARY*.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 649d8fb..c852469 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,118 @@ All notable changes to FuzzForge will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). -## [0.7.0] - 2025-01-16 +## [Unreleased] + +### 📝 Documentation +- Added comprehensive worker startup documentation across all guides +- Added workflow-to-worker mapping tables in README, troubleshooting guide, getting started guide, and docker setup guide +- Fixed broken documentation links in CLI reference +- Added WEEK_SUMMARY*.md pattern to .gitignore + +--- + +## [0.7.3] - 2025-10-30 + +### 🎯 Major Features + +#### Android Static Analysis Workflow +- **Added comprehensive Android security testing workflow** (`android_static_analysis`): + - Jadx decompiler for APK → Java source code decompilation + - OpenGrep/Semgrep static analysis with custom Android security rules + - MobSF integration for comprehensive mobile security scanning + - SARIF report generation with unified findings format + - Test results: Successfully decompiled 4,145 Java files, found 8 security vulnerabilities + - Full workflow completes in ~1.5 minutes + +#### Platform-Aware Worker Architecture +- **ARM64 (Apple Silicon) support**: + - Automatic platform detection (ARM64 vs x86_64) in CLI using `platform.machine()` + - Worker metadata convention (`metadata.yaml`) for platform-specific capabilities + - Multi-Dockerfile support: `Dockerfile.amd64` (full toolchain) and `Dockerfile.arm64` (optimized) + - Conditional module imports for graceful degradation (MobSF skips on ARM64) + - Backend path resolution via `FUZZFORGE_HOST_ROOT` for CLI worker management +- **Worker selection logic**: + - CLI automatically selects appropriate Dockerfile based on detected platform + - Multi-strategy path resolution (API → .fuzzforge marker → environment variable) + - Platform-specific tool availability documented in metadata + +#### Python SAST Workflow +- **Added Python Static Application Security Testing workflow** (`python_sast`): + - Bandit for Python security linting (SAST) + - MyPy for static type checking + - Safety for dependency vulnerability scanning + - Integrated SARIF reporter for unified findings format + - Auto-start Python worker on-demand + +### ✨ Enhancements + +#### CI/CD Improvements +- Added automated worker validation in CI pipeline +- Docker build checks for all workers before merge +- Worker file change detection for selective builds +- Optimized Docker layer caching for faster builds +- Dev branch testing workflow triggers + +#### CLI Improvements +- Fixed live monitoring bug in `ff monitor live` command +- Enhanced `ff findings` command with better table formatting +- Improved `ff monitor` with clearer status displays +- Auto-start workers on-demand when workflows require them +- Better error messages with actionable manual start commands + +#### Worker Management +- Standardized worker service names (`worker-python`, `worker-android`, etc.) +- Added missing `worker-secrets` to repository +- Improved worker naming consistency across codebase + +#### LiteLLM Integration +- Centralized LLM provider management with proxy +- Governance and request/response routing +- OTEL collector integration for observability +- Environment-based configurable timeouts +- Optional `.env.litellm` configuration + +### 🐛 Bug Fixes + +- Fixed MobSF API key generation from secret file (SHA256 hash) +- Corrected Temporal activity names (decompile_with_jadx, scan_with_opengrep, scan_with_mobsf) +- Resolved linter errors across codebase +- Fixed unused import issues to pass CI checks +- Removed deprecated workflow parameters +- Docker Compose version compatibility fixes + +### 🔧 Technical Changes + +- Conditional import pattern for optional dependencies (MobSF on ARM64) +- Multi-platform Dockerfile architecture +- Worker metadata convention for capability declaration +- Improved CI worker build optimization +- Enhanced storage activity error handling + +### 📝 Test Projects + +- Added `test_projects/android_test/` with BeetleBug.apk and shopnest.apk +- Android workflow validation with real APK samples +- ARM64 platform testing and validation + +--- + +## [0.7.2] - 2025-10-22 + +### 🐛 Bug Fixes +- Fixed worker naming inconsistencies across codebase +- Improved monitor command consolidation and usability +- Enhanced findings CLI with better formatting and display +- Added missing secrets worker to repository + +### 📝 Documentation +- Added benchmark results files to git for secret detection workflows + +**Note:** v0.7.1 was re-tagged as v0.7.2 (both point to the same commit) + +--- + +## [0.7.0] - 2025-10-16 ### 🎯 Major Features @@ -40,7 +151,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 #### Documentation - Updated README for Temporal + MinIO architecture -- Removed obsolete `volume_mode` references across all documentation - Added `.env` configuration guide for AI agent API keys - Fixed worker startup instructions with correct service names - Updated docker compose commands to modern syntax @@ -52,6 +162,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### 🐛 Bug Fixes +- Fixed default parameters from metadata.yaml not being applied to workflows when no parameters provided - Fixed gitleaks workflow failing on uploaded directories without Git history - Fixed worker startup command suggestions (now uses `docker compose up -d` with service names) - Fixed missing `cognify_text` method in CogneeProjectIntegration @@ -71,7 +182,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 --- -## [0.6.0] - 2024-12-XX +## [0.6.0] - Undocumented ### Features - Initial Temporal migration @@ -79,7 +190,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Security assessment workflow - Basic CLI commands +**Note:** No git tag exists for v0.6.0. Release date undocumented. + --- -[0.7.0]: https://github.com/FuzzingLabs/fuzzforge_ai/compare/v0.6.0...v0.7.0 -[0.6.0]: https://github.com/FuzzingLabs/fuzzforge_ai/releases/tag/v0.6.0 +[0.7.3]: https://github.com/FuzzingLabs/fuzzforge_ai/compare/v0.7.2...v0.7.3 +[0.7.2]: https://github.com/FuzzingLabs/fuzzforge_ai/compare/v0.7.0...v0.7.2 +[0.7.0]: https://github.com/FuzzingLabs/fuzzforge_ai/releases/tag/v0.7.0 +[0.6.0]: https://github.com/FuzzingLabs/fuzzforge_ai/tree/v0.6.0 diff --git a/README.md b/README.md index 9b8eaaf..f76dcce 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ License: BSL + Apache Python 3.11+ Website - Version + Version GitHub Stars

@@ -115,9 +115,11 @@ For containerized workflows, see the [Docker Installation Guide](https://docs.do For AI-powered workflows, configure your LLM API keys: ```bash -cp volumes/env/.env.example volumes/env/.env +cp volumes/env/.env.template volumes/env/.env # Edit volumes/env/.env and add your API keys (OpenAI, Anthropic, Google, etc.) +# Add your key to LITELLM_GEMINI_API_KEY ``` +> Dont change the OPENAI_API_KEY default value, as it is used for the LLM proxy. This is required for: - `llm_secret_detection` workflow @@ -150,7 +152,7 @@ git clone https://github.com/fuzzinglabs/fuzzforge_ai.git cd fuzzforge_ai # 2. Copy the default LLM env config -cp volumes/env/.env.example volumes/env/.env +cp volumes/env/.env.template volumes/env/.env # 3. Start FuzzForge with Temporal docker compose up -d @@ -163,6 +165,16 @@ docker compose up -d worker-python > > Workers don't auto-start by default (saves RAM). Start the worker you need before running workflows. +**Workflow-to-Worker Quick Reference:** + +| Workflow | Worker Required | Startup Command | +|----------|----------------|-----------------| +| `security_assessment`, `python_sast`, `llm_analysis`, `atheris_fuzzing` | worker-python | `docker compose up -d worker-python` | +| `android_static_analysis` | worker-android | `docker compose up -d worker-android` | +| `cargo_fuzzing` | worker-rust | `docker compose up -d worker-rust` | +| `ossfuzz_campaign` | worker-ossfuzz | `docker compose up -d worker-ossfuzz` | +| `llm_secret_detection`, `trufflehog_detection`, `gitleaks_detection` | worker-secrets | `docker compose up -d worker-secrets` | + ```bash # 5. Run your first workflow (files are automatically uploaded) cd test_projects/vulnerable_app/ diff --git a/ai/agents/task_agent/.env.example b/ai/agents/task_agent/.env.example deleted file mode 100644 index c71d59a..0000000 --- a/ai/agents/task_agent/.env.example +++ /dev/null @@ -1,10 +0,0 @@ -# Default LiteLLM configuration -LITELLM_MODEL=gemini/gemini-2.0-flash-001 -# LITELLM_PROVIDER=gemini - -# API keys (uncomment and fill as needed) -# GOOGLE_API_KEY= -# OPENAI_API_KEY= -# ANTHROPIC_API_KEY= -# OPENROUTER_API_KEY= -# MISTRAL_API_KEY= diff --git a/ai/agents/task_agent/Dockerfile b/ai/agents/task_agent/Dockerfile index eaf734b..c2b6686 100644 --- a/ai/agents/task_agent/Dockerfile +++ b/ai/agents/task_agent/Dockerfile @@ -16,4 +16,9 @@ COPY . /app/agent_with_adk_format WORKDIR /app/agent_with_adk_format ENV PYTHONPATH=/app +# Copy and set up entrypoint +COPY docker-entrypoint.sh /docker-entrypoint.sh +RUN chmod +x /docker-entrypoint.sh + +ENTRYPOINT ["/docker-entrypoint.sh"] CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/ai/agents/task_agent/README.md b/ai/agents/task_agent/README.md index 769ce33..692e4e6 100644 --- a/ai/agents/task_agent/README.md +++ b/ai/agents/task_agent/README.md @@ -43,18 +43,34 @@ cd task_agent # cp .env.example .env ``` -Edit `.env` (or `.env.example`) and add your API keys. The agent must be restarted after changes so the values are picked up: +Edit `.env` (or `.env.example`) and add your proxy + API keys. The agent must be restarted after changes so the values are picked up: ```bash -# Set default model -LITELLM_MODEL=gemini/gemini-2.0-flash-001 +# Route every request through the proxy container (use http://localhost:10999 from the host) +FF_LLM_PROXY_BASE_URL=http://llm-proxy:4000 -# Add API keys for providers you want to use -GOOGLE_API_KEY=your_google_api_key -OPENAI_API_KEY=your_openai_api_key -ANTHROPIC_API_KEY=your_anthropic_api_key -OPENROUTER_API_KEY=your_openrouter_api_key +# Default model + provider the agent boots with +LITELLM_MODEL=openai/gpt-4o-mini +LITELLM_PROVIDER=openai + +# Virtual key issued by the proxy to the task agent (bootstrap replaces the placeholder) +OPENAI_API_KEY=sk-proxy-default + +# Upstream keys stay inside the proxy. Store real secrets under the LiteLLM +# aliases and the bootstrapper mirrors them into .env.litellm for the proxy container. +LITELLM_OPENAI_API_KEY=your_real_openai_api_key +LITELLM_ANTHROPIC_API_KEY=your_real_anthropic_key +LITELLM_GEMINI_API_KEY=your_real_gemini_key +LITELLM_MISTRAL_API_KEY=your_real_mistral_key +LITELLM_OPENROUTER_API_KEY=your_real_openrouter_key ``` +> When running the agent outside of Docker, swap `FF_LLM_PROXY_BASE_URL` to the host port (default `http://localhost:10999`). + +The bootstrap container provisions LiteLLM, copies provider secrets into +`volumes/env/.env.litellm`, and rewrites `volumes/env/.env` with the virtual key. +Populate the `LITELLM_*_API_KEY` values before the first launch so the proxy can +reach your upstream providers as soon as the bootstrap script runs. + ### 2. Install Dependencies ```bash diff --git a/ai/agents/task_agent/docker-entrypoint.sh b/ai/agents/task_agent/docker-entrypoint.sh new file mode 100644 index 0000000..88e3733 --- /dev/null +++ b/ai/agents/task_agent/docker-entrypoint.sh @@ -0,0 +1,31 @@ +#!/bin/bash +set -e + +# Wait for .env file to have keys (max 30 seconds) +echo "[task-agent] Waiting for virtual keys to be provisioned..." +for i in $(seq 1 30); do + if [ -f /app/config/.env ]; then + # Check if TASK_AGENT_API_KEY has a value (not empty) + KEY=$(grep -E '^TASK_AGENT_API_KEY=' /app/config/.env | cut -d'=' -f2) + if [ -n "$KEY" ] && [ "$KEY" != "" ]; then + echo "[task-agent] Virtual keys found, loading environment..." + # Export keys from .env file + export TASK_AGENT_API_KEY="$KEY" + export OPENAI_API_KEY=$(grep -E '^OPENAI_API_KEY=' /app/config/.env | cut -d'=' -f2) + export FF_LLM_PROXY_BASE_URL=$(grep -E '^FF_LLM_PROXY_BASE_URL=' /app/config/.env | cut -d'=' -f2) + echo "[task-agent] Loaded TASK_AGENT_API_KEY: ${TASK_AGENT_API_KEY:0:15}..." + echo "[task-agent] Loaded FF_LLM_PROXY_BASE_URL: $FF_LLM_PROXY_BASE_URL" + break + fi + fi + echo "[task-agent] Keys not ready yet, waiting... ($i/30)" + sleep 1 +done + +if [ -z "$TASK_AGENT_API_KEY" ]; then + echo "[task-agent] ERROR: Virtual keys were not provisioned within 30 seconds!" + exit 1 +fi + +echo "[task-agent] Starting uvicorn..." +exec "$@" diff --git a/ai/agents/task_agent/litellm_agent/config.py b/ai/agents/task_agent/litellm_agent/config.py index 9b404bf..54ab609 100644 --- a/ai/agents/task_agent/litellm_agent/config.py +++ b/ai/agents/task_agent/litellm_agent/config.py @@ -4,13 +4,28 @@ from __future__ import annotations import os + +def _normalize_proxy_base_url(raw_value: str | None) -> str | None: + if not raw_value: + return None + cleaned = raw_value.strip() + if not cleaned: + return None + # Avoid double slashes in downstream requests + return cleaned.rstrip("/") + AGENT_NAME = "litellm_agent" AGENT_DESCRIPTION = ( "A LiteLLM-backed shell that exposes hot-swappable model and prompt controls." ) -DEFAULT_MODEL = os.getenv("LITELLM_MODEL", "gemini-2.0-flash-001") -DEFAULT_PROVIDER = os.getenv("LITELLM_PROVIDER") +DEFAULT_MODEL = os.getenv("LITELLM_MODEL", "openai/gpt-4o-mini") +DEFAULT_PROVIDER = os.getenv("LITELLM_PROVIDER") or None +PROXY_BASE_URL = _normalize_proxy_base_url( + os.getenv("FF_LLM_PROXY_BASE_URL") + or os.getenv("LITELLM_API_BASE") + or os.getenv("LITELLM_BASE_URL") +) STATE_PREFIX = "app:litellm_agent/" STATE_MODEL_KEY = f"{STATE_PREFIX}model" diff --git a/ai/agents/task_agent/litellm_agent/state.py b/ai/agents/task_agent/litellm_agent/state.py index 460d961..54f1308 100644 --- a/ai/agents/task_agent/litellm_agent/state.py +++ b/ai/agents/task_agent/litellm_agent/state.py @@ -3,11 +3,15 @@ from __future__ import annotations from dataclasses import dataclass +import os from typing import Any, Mapping, MutableMapping, Optional +import httpx + from .config import ( DEFAULT_MODEL, DEFAULT_PROVIDER, + PROXY_BASE_URL, STATE_MODEL_KEY, STATE_PROMPT_KEY, STATE_PROVIDER_KEY, @@ -66,11 +70,109 @@ class HotSwapState: """Create a LiteLlm instance for the current state.""" from google.adk.models.lite_llm import LiteLlm # Lazy import to avoid cycle + from google.adk.models.lite_llm import LiteLLMClient + from litellm.types.utils import Choices, Message, ModelResponse, Usage kwargs = {"model": self.model} if self.provider: kwargs["custom_llm_provider"] = self.provider - return LiteLlm(**kwargs) + if PROXY_BASE_URL: + provider = (self.provider or DEFAULT_PROVIDER or "").lower() + if provider and provider != "openai": + kwargs["api_base"] = f"{PROXY_BASE_URL.rstrip('/')}/{provider}" + else: + kwargs["api_base"] = PROXY_BASE_URL + kwargs.setdefault("api_key", os.environ.get("TASK_AGENT_API_KEY") or os.environ.get("OPENAI_API_KEY")) + + provider = (self.provider or DEFAULT_PROVIDER or "").lower() + model_suffix = self.model.split("/", 1)[-1] + use_responses = provider == "openai" and ( + model_suffix.startswith("gpt-5") or model_suffix.startswith("o1") + ) + if use_responses: + kwargs.setdefault("use_responses_api", True) + + llm = LiteLlm(**kwargs) + + if use_responses and PROXY_BASE_URL: + + class _ResponsesAwareClient(LiteLLMClient): + def __init__(self, base_client: LiteLLMClient, api_base: str, api_key: str): + self._base_client = base_client + self._api_base = api_base.rstrip("/") + self._api_key = api_key + + async def acompletion(self, model, messages, tools, **kwargs): # type: ignore[override] + use_responses_api = kwargs.pop("use_responses_api", False) + if not use_responses_api: + return await self._base_client.acompletion( + model=model, + messages=messages, + tools=tools, + **kwargs, + ) + + resolved_model = model + if "/" not in resolved_model: + resolved_model = f"openai/{resolved_model}" + + payload = { + "model": resolved_model, + "input": _messages_to_responses_input(messages), + } + + timeout = kwargs.get("timeout", 60) + headers = { + "Authorization": f"Bearer {self._api_key}", + "Content-Type": "application/json", + } + + async with httpx.AsyncClient(timeout=timeout) as client: + response = await client.post( + f"{self._api_base}/v1/responses", + json=payload, + headers=headers, + ) + try: + response.raise_for_status() + except httpx.HTTPStatusError as exc: + text = exc.response.text + raise RuntimeError( + f"LiteLLM responses request failed: {text}" + ) from exc + data = response.json() + + text_output = _extract_output_text(data) + usage = data.get("usage", {}) + + return ModelResponse( + id=data.get("id"), + model=model, + choices=[ + Choices( + finish_reason="stop", + index=0, + message=Message(role="assistant", content=text_output), + provider_specific_fields={"bifrost_response": data}, + ) + ], + usage=Usage( + prompt_tokens=usage.get("input_tokens"), + completion_tokens=usage.get("output_tokens"), + reasoning_tokens=usage.get("output_tokens_details", {}).get( + "reasoning_tokens" + ), + total_tokens=usage.get("total_tokens"), + ), + ) + + llm.llm_client = _ResponsesAwareClient( + llm.llm_client, + PROXY_BASE_URL, + os.environ.get("TASK_AGENT_API_KEY") or os.environ.get("OPENAI_API_KEY", ""), + ) + + return llm @property def display_model(self) -> str: @@ -84,3 +186,69 @@ def apply_state_to_agent(invocation_context, state: HotSwapState) -> None: agent = invocation_context.agent agent.model = state.instantiate_llm() + + +def _messages_to_responses_input(messages: list[dict[str, Any]]) -> list[dict[str, Any]]: + inputs: list[dict[str, Any]] = [] + for message in messages: + role = message.get("role", "user") + content = message.get("content", "") + text_segments: list[str] = [] + + if isinstance(content, list): + for item in content: + if isinstance(item, dict): + text = item.get("text") or item.get("content") + if text: + text_segments.append(str(text)) + elif isinstance(item, str): + text_segments.append(item) + elif isinstance(content, str): + text_segments.append(content) + + text = "\n".join(segment.strip() for segment in text_segments if segment) + if not text: + continue + + entry_type = "input_text" + if role == "assistant": + entry_type = "output_text" + + inputs.append( + { + "role": role, + "content": [ + { + "type": entry_type, + "text": text, + } + ], + } + ) + + if not inputs: + inputs.append( + { + "role": "user", + "content": [ + { + "type": "input_text", + "text": "", + } + ], + } + ) + return inputs + + +def _extract_output_text(response_json: dict[str, Any]) -> str: + outputs = response_json.get("output", []) + collected: list[str] = [] + for item in outputs: + if isinstance(item, dict) and item.get("type") == "message": + for part in item.get("content", []): + if isinstance(part, dict) and part.get("type") == "output_text": + text = part.get("text", "") + if text: + collected.append(str(text)) + return "\n\n".join(collected).strip() diff --git a/ai/proxy/README.md b/ai/proxy/README.md new file mode 100644 index 0000000..fc941eb --- /dev/null +++ b/ai/proxy/README.md @@ -0,0 +1,5 @@ +# LLM Proxy Integrations + +This directory contains vendor source trees that were vendored only for reference when integrating LLM gateways. The actual FuzzForge deployment uses the official Docker images for each project. + +See `docs/docs/how-to/llm-proxy.md` for up-to-date instructions on running the proxy services and issuing keys for the agents. diff --git a/ai/pyproject.toml b/ai/pyproject.toml index d5c0e77..120b9cc 100644 --- a/ai/pyproject.toml +++ b/ai/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "fuzzforge-ai" -version = "0.7.0" +version = "0.7.3" description = "FuzzForge AI orchestration module" readme = "README.md" requires-python = ">=3.11" diff --git a/ai/src/fuzzforge_ai/__init__.py b/ai/src/fuzzforge_ai/__init__.py index cca81fc..eefecd9 100644 --- a/ai/src/fuzzforge_ai/__init__.py +++ b/ai/src/fuzzforge_ai/__init__.py @@ -21,4 +21,4 @@ Usage: # Additional attribution and requirements are provided in the NOTICE file. -__version__ = "0.6.0" \ No newline at end of file +__version__ = "0.7.3" \ No newline at end of file diff --git a/ai/src/fuzzforge_ai/agent_executor.py b/ai/src/fuzzforge_ai/agent_executor.py index fd1f1d9..41613c0 100644 --- a/ai/src/fuzzforge_ai/agent_executor.py +++ b/ai/src/fuzzforge_ai/agent_executor.py @@ -831,20 +831,9 @@ class FuzzForgeExecutor: async def submit_security_scan_mcp( workflow_name: str, target_path: str = "", - volume_mode: str = "", parameters: Dict[str, Any] | None = None, tool_context: ToolContext | None = None, ) -> Any: - # Normalise volume mode to supported values - normalised_mode = (volume_mode or "ro").strip().lower().replace("-", "_") - if normalised_mode in {"read_only", "readonly", "ro"}: - normalised_mode = "ro" - elif normalised_mode in {"read_write", "readwrite", "rw"}: - normalised_mode = "rw" - else: - # Fall back to read-only if we can't recognise the input - normalised_mode = "ro" - # Resolve the target path to an absolute path for validation resolved_path = target_path or "." try: @@ -883,7 +872,6 @@ class FuzzForgeExecutor: payload = { "workflow_name": workflow_name, "target_path": resolved_path, - "volume_mode": normalised_mode, "parameters": cleaned_parameters, } result = await _call_fuzzforge_mcp("submit_security_scan_mcp", payload) @@ -1061,10 +1049,19 @@ class FuzzForgeExecutor: FunctionTool(get_task_list) ]) - - # Create the agent + + # Create the agent with LiteLLM configuration + llm_kwargs = {} + api_key = os.getenv('OPENAI_API_KEY') or os.getenv('LLM_API_KEY') + api_base = os.getenv('LLM_ENDPOINT') or os.getenv('LLM_API_BASE') or os.getenv('OPENAI_API_BASE') + + if api_key: + llm_kwargs['api_key'] = api_key + if api_base: + llm_kwargs['api_base'] = api_base + self.agent = LlmAgent( - model=LiteLlm(model=self.model), + model=LiteLlm(model=self.model, **llm_kwargs), name="fuzzforge_executor", description="Intelligent A2A orchestrator with memory", instruction=self._build_instruction(), diff --git a/ai/src/fuzzforge_ai/cognee_service.py b/ai/src/fuzzforge_ai/cognee_service.py index 968e956..ba14a30 100644 --- a/ai/src/fuzzforge_ai/cognee_service.py +++ b/ai/src/fuzzforge_ai/cognee_service.py @@ -56,7 +56,7 @@ class CogneeService: # Configure LLM with API key BEFORE any other cognee operations provider = os.getenv("LLM_PROVIDER", "openai") model = os.getenv("LLM_MODEL") or os.getenv("LITELLM_MODEL", "gpt-4o-mini") - api_key = os.getenv("LLM_API_KEY") or os.getenv("OPENAI_API_KEY") + api_key = os.getenv("COGNEE_API_KEY") or os.getenv("LLM_API_KEY") or os.getenv("OPENAI_API_KEY") endpoint = os.getenv("LLM_ENDPOINT") api_version = os.getenv("LLM_API_VERSION") max_tokens = os.getenv("LLM_MAX_TOKENS") @@ -78,48 +78,62 @@ class CogneeService: os.environ.setdefault("OPENAI_API_KEY", api_key) if endpoint: os.environ["LLM_ENDPOINT"] = endpoint + os.environ.setdefault("LLM_API_BASE", endpoint) + os.environ.setdefault("OPENAI_API_BASE", endpoint) + os.environ.setdefault("LITELLM_PROXY_API_BASE", endpoint) + if api_key: + os.environ.setdefault("LITELLM_PROXY_API_KEY", api_key) if api_version: os.environ["LLM_API_VERSION"] = api_version if max_tokens: os.environ["LLM_MAX_TOKENS"] = str(max_tokens) # Configure Cognee's runtime using its configuration helpers when available + embedding_model = os.getenv("LLM_EMBEDDING_MODEL") + embedding_endpoint = os.getenv("LLM_EMBEDDING_ENDPOINT") + if embedding_endpoint: + os.environ.setdefault("LLM_EMBEDDING_API_BASE", embedding_endpoint) + if hasattr(cognee.config, "set_llm_provider"): cognee.config.set_llm_provider(provider) - if hasattr(cognee.config, "set_llm_model"): - cognee.config.set_llm_model(model) - if api_key and hasattr(cognee.config, "set_llm_api_key"): - cognee.config.set_llm_api_key(api_key) - if endpoint and hasattr(cognee.config, "set_llm_endpoint"): - cognee.config.set_llm_endpoint(endpoint) + if hasattr(cognee.config, "set_llm_model"): + cognee.config.set_llm_model(model) + if api_key and hasattr(cognee.config, "set_llm_api_key"): + cognee.config.set_llm_api_key(api_key) + if endpoint and hasattr(cognee.config, "set_llm_endpoint"): + cognee.config.set_llm_endpoint(endpoint) + if embedding_model and hasattr(cognee.config, "set_llm_embedding_model"): + cognee.config.set_llm_embedding_model(embedding_model) + if embedding_endpoint and hasattr(cognee.config, "set_llm_embedding_endpoint"): + cognee.config.set_llm_embedding_endpoint(embedding_endpoint) if api_version and hasattr(cognee.config, "set_llm_api_version"): cognee.config.set_llm_api_version(api_version) if max_tokens and hasattr(cognee.config, "set_llm_max_tokens"): cognee.config.set_llm_max_tokens(int(max_tokens)) - + # Configure graph database cognee.config.set_graph_db_config({ "graph_database_provider": self.cognee_config.get("graph_database_provider", "kuzu"), }) - + # Set data directories data_dir = self.cognee_config.get("data_directory") system_dir = self.cognee_config.get("system_directory") - + if data_dir: logger.debug("Setting cognee data root", extra={"path": data_dir}) cognee.config.data_root_directory(data_dir) if system_dir: logger.debug("Setting cognee system root", extra={"path": system_dir}) cognee.config.system_root_directory(system_dir) - + # Setup multi-tenant user context await self._setup_user_context() - + self._initialized = True logger.info(f"Cognee initialized for project {self.project_context['project_name']} " f"with Kuzu at {system_dir}") - + except ImportError: logger.error("Cognee not installed. Install with: pip install cognee") raise diff --git a/backend/mcp-config.json b/backend/mcp-config.json index 1b6e783..4f06ce4 100644 --- a/backend/mcp-config.json +++ b/backend/mcp-config.json @@ -22,7 +22,6 @@ "parameters": { "workflow_name": "string", "target_path": "string", - "volume_mode": "string (ro|rw)", "parameters": "object" } }, diff --git a/backend/pyproject.toml b/backend/pyproject.toml index 03a7307..595d473 100644 --- a/backend/pyproject.toml +++ b/backend/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "backend" -version = "0.7.0" +version = "0.7.3" description = "FuzzForge OSS backend" authors = [] readme = "README.md" diff --git a/backend/src/api/system.py b/backend/src/api/system.py new file mode 100644 index 0000000..a4ee1a6 --- /dev/null +++ b/backend/src/api/system.py @@ -0,0 +1,47 @@ +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +""" +System information endpoints for FuzzForge API. + +Provides system configuration and filesystem paths to CLI for worker management. +""" + +import os +from typing import Dict + +from fastapi import APIRouter + +router = APIRouter(prefix="/system", tags=["system"]) + + +@router.get("/info") +async def get_system_info() -> Dict[str, str]: + """ + Get system information including host filesystem paths. + + This endpoint exposes paths needed by the CLI to manage workers via docker-compose. + The FUZZFORGE_HOST_ROOT environment variable is set by docker-compose and points + to the FuzzForge installation directory on the host machine. + + Returns: + Dictionary containing: + - host_root: Absolute path to FuzzForge root on host + - docker_compose_path: Path to docker-compose.yml on host + - workers_dir: Path to workers directory on host + """ + host_root = os.getenv("FUZZFORGE_HOST_ROOT", "") + + return { + "host_root": host_root, + "docker_compose_path": f"{host_root}/docker-compose.yml" if host_root else "", + "workers_dir": f"{host_root}/workers" if host_root else "", + } diff --git a/backend/src/api/workflows.py b/backend/src/api/workflows.py index 3ffda9d..a4d1b7c 100644 --- a/backend/src/api/workflows.py +++ b/backend/src/api/workflows.py @@ -43,6 +43,42 @@ ALLOWED_CONTENT_TYPES = [ router = APIRouter(prefix="/workflows", tags=["workflows"]) +def extract_defaults_from_json_schema(metadata: Dict[str, Any]) -> Dict[str, Any]: + """ + Extract default parameter values from JSON Schema format. + + Converts from: + parameters: + properties: + param_name: + default: value + + To: + {param_name: value} + + Args: + metadata: Workflow metadata dictionary + + Returns: + Dictionary of parameter defaults + """ + defaults = {} + + # Check if there's a legacy default_parameters field + if "default_parameters" in metadata: + defaults.update(metadata["default_parameters"]) + + # Extract defaults from JSON Schema parameters + parameters = metadata.get("parameters", {}) + properties = parameters.get("properties", {}) + + for param_name, param_spec in properties.items(): + if "default" in param_spec: + defaults[param_name] = param_spec["default"] + + return defaults + + def create_structured_error_response( error_type: str, message: str, @@ -164,7 +200,7 @@ async def get_workflow_metadata( author=metadata.get("author"), tags=metadata.get("tags", []), parameters=metadata.get("parameters", {}), - default_parameters=metadata.get("default_parameters", {}), + default_parameters=extract_defaults_from_json_schema(metadata), required_modules=metadata.get("required_modules", []) ) @@ -221,7 +257,7 @@ async def submit_workflow( # Merge default parameters with user parameters workflow_info = temporal_mgr.workflows[workflow_name] metadata = workflow_info.metadata or {} - defaults = metadata.get("default_parameters", {}) + defaults = extract_defaults_from_json_schema(metadata) user_params = submission.parameters or {} workflow_params = {**defaults, **user_params} @@ -450,7 +486,7 @@ async def upload_and_submit_workflow( # Merge default parameters with user parameters workflow_info = temporal_mgr.workflows.get(workflow_name) metadata = workflow_info.metadata or {} - defaults = metadata.get("default_parameters", {}) + defaults = extract_defaults_from_json_schema(metadata) workflow_params = {**defaults, **workflow_params} # Start workflow execution @@ -617,11 +653,8 @@ async def get_workflow_parameters( else: param_definitions = parameters_schema - # Add default values to the schema - default_params = metadata.get("default_parameters", {}) - for param_name, param_schema in param_definitions.items(): - if isinstance(param_schema, dict) and param_name in default_params: - param_schema["default"] = default_params[param_name] + # Extract default values from JSON Schema + default_params = extract_defaults_from_json_schema(metadata) return { "workflow": workflow_name, diff --git a/backend/src/main.py b/backend/src/main.py index 9866c43..c219742 100644 --- a/backend/src/main.py +++ b/backend/src/main.py @@ -24,7 +24,7 @@ from fastmcp.server.http import create_sse_app from src.temporal.manager import TemporalManager from src.core.setup import setup_result_storage, validate_infrastructure -from src.api import workflows, runs, fuzzing +from src.api import workflows, runs, fuzzing, system from fastmcp import FastMCP @@ -76,6 +76,7 @@ app = FastAPI( app.include_router(workflows.router) app.include_router(runs.router) app.include_router(fuzzing.router) +app.include_router(system.router) def get_temporal_status() -> Dict[str, Any]: @@ -212,14 +213,6 @@ def _lookup_workflow(workflow_name: str): metadata = info.metadata defaults = metadata.get("default_parameters", {}) default_target_path = metadata.get("default_target_path") or defaults.get("target_path") - supported_modes = metadata.get("supported_volume_modes") or ["ro", "rw"] - if not isinstance(supported_modes, list) or not supported_modes: - supported_modes = ["ro", "rw"] - default_volume_mode = ( - metadata.get("default_volume_mode") - or defaults.get("volume_mode") - or supported_modes[0] - ) return { "name": workflow_name, "version": metadata.get("version", "0.6.0"), @@ -229,9 +222,7 @@ def _lookup_workflow(workflow_name: str): "parameters": metadata.get("parameters", {}), "default_parameters": metadata.get("default_parameters", {}), "required_modules": metadata.get("required_modules", []), - "supported_volume_modes": supported_modes, - "default_target_path": default_target_path, - "default_volume_mode": default_volume_mode + "default_target_path": default_target_path } @@ -256,10 +247,6 @@ async def list_workflows_mcp() -> Dict[str, Any]: "description": metadata.get("description", ""), "author": metadata.get("author"), "tags": metadata.get("tags", []), - "supported_volume_modes": metadata.get("supported_volume_modes", ["ro", "rw"]), - "default_volume_mode": metadata.get("default_volume_mode") - or defaults.get("volume_mode") - or "ro", "default_target_path": metadata.get("default_target_path") or defaults.get("target_path") }) diff --git a/backend/src/models/findings.py b/backend/src/models/findings.py index ddc756a..b71a9b6 100644 --- a/backend/src/models/findings.py +++ b/backend/src/models/findings.py @@ -14,7 +14,7 @@ Models for workflow findings and submissions # Additional attribution and requirements are provided in the NOTICE file. from pydantic import BaseModel, Field -from typing import Dict, Any, Optional, Literal, List +from typing import Dict, Any, Optional, List from datetime import datetime @@ -73,10 +73,6 @@ class WorkflowMetadata(BaseModel): default_factory=list, description="Required module names" ) - supported_volume_modes: List[Literal["ro", "rw"]] = Field( - default=["ro", "rw"], - description="Supported volume mount modes" - ) class WorkflowListItem(BaseModel): diff --git a/backend/src/temporal/manager.py b/backend/src/temporal/manager.py index 9a44e8b..96d9a84 100644 --- a/backend/src/temporal/manager.py +++ b/backend/src/temporal/manager.py @@ -187,12 +187,28 @@ class TemporalManager: # Add parameters in order based on metadata schema # This ensures parameters match the workflow signature order - if workflow_params and 'parameters' in workflow_info.metadata: + # Apply defaults from metadata.yaml if parameter not provided + if 'parameters' in workflow_info.metadata: param_schema = workflow_info.metadata['parameters'].get('properties', {}) + logger.debug(f"Found {len(param_schema)} parameters in schema") # Iterate parameters in schema order and add values for param_name in param_schema.keys(): - param_value = workflow_params.get(param_name) + param_spec = param_schema[param_name] + + # Use provided param, or fall back to default from metadata + if workflow_params and param_name in workflow_params: + param_value = workflow_params[param_name] + logger.debug(f"Using provided value for {param_name}: {param_value}") + elif 'default' in param_spec: + param_value = param_spec['default'] + logger.debug(f"Using default for {param_name}: {param_value}") + else: + param_value = None + logger.debug(f"No value or default for {param_name}, using None") + workflow_args.append(param_value) + else: + logger.debug("No 'parameters' section found in workflow metadata") # Determine task queue from workflow vertical vertical = workflow_info.metadata.get("vertical", "default") diff --git a/backend/toolbox/modules/analyzer/__init__.py b/backend/toolbox/modules/analyzer/__init__.py index 527dab7..8bffdab 100644 --- a/backend/toolbox/modules/analyzer/__init__.py +++ b/backend/toolbox/modules/analyzer/__init__.py @@ -10,5 +10,7 @@ # Additional attribution and requirements are provided in the NOTICE file. from .security_analyzer import SecurityAnalyzer +from .bandit_analyzer import BanditAnalyzer +from .mypy_analyzer import MypyAnalyzer -__all__ = ["SecurityAnalyzer"] \ No newline at end of file +__all__ = ["SecurityAnalyzer", "BanditAnalyzer", "MypyAnalyzer"] \ No newline at end of file diff --git a/backend/toolbox/modules/analyzer/bandit_analyzer.py b/backend/toolbox/modules/analyzer/bandit_analyzer.py new file mode 100644 index 0000000..ecf81a8 --- /dev/null +++ b/backend/toolbox/modules/analyzer/bandit_analyzer.py @@ -0,0 +1,328 @@ +""" +Bandit Analyzer Module - Analyzes Python code for security issues using Bandit +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +import asyncio +import json +import logging +import time +from pathlib import Path +from typing import Dict, Any, List + +try: + from toolbox.modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding +except ImportError: + try: + from modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding + except ImportError: + from src.toolbox.modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding + +logger = logging.getLogger(__name__) + + +class BanditAnalyzer(BaseModule): + """ + Analyzes Python code for security issues using Bandit. + + This module: + - Runs Bandit security linter on Python files + - Detects common security issues (SQL injection, hardcoded secrets, etc.) + - Reports findings with severity levels + """ + + # Severity mapping from Bandit levels to our standard + SEVERITY_MAP = { + "LOW": "low", + "MEDIUM": "medium", + "HIGH": "high" + } + + def get_metadata(self) -> ModuleMetadata: + """Get module metadata""" + return ModuleMetadata( + name="bandit_analyzer", + version="1.0.0", + description="Analyzes Python code for security issues using Bandit", + author="FuzzForge Team", + category="analyzer", + tags=["python", "security", "bandit", "sast"], + input_schema={ + "severity_level": { + "type": "string", + "enum": ["low", "medium", "high"], + "description": "Minimum severity level to report", + "default": "low" + }, + "confidence_level": { + "type": "string", + "enum": ["low", "medium", "high"], + "description": "Minimum confidence level to report", + "default": "medium" + }, + "exclude_tests": { + "type": "boolean", + "description": "Exclude test files from analysis", + "default": True + }, + "skip_ids": { + "type": "array", + "items": {"type": "string"}, + "description": "List of Bandit test IDs to skip", + "default": [] + } + }, + output_schema={ + "findings": { + "type": "array", + "description": "List of security issues found by Bandit" + } + }, + requires_workspace=True + ) + + def validate_config(self, config: Dict[str, Any]) -> bool: + """Validate module configuration""" + severity = config.get("severity_level", "low") + if severity not in ["low", "medium", "high"]: + raise ValueError("severity_level must be one of: low, medium, high") + + confidence = config.get("confidence_level", "medium") + if confidence not in ["low", "medium", "high"]: + raise ValueError("confidence_level must be one of: low, medium, high") + + skip_ids = config.get("skip_ids", []) + if not isinstance(skip_ids, list): + raise ValueError("skip_ids must be a list") + + return True + + async def _run_bandit( + self, + workspace: Path, + severity_level: str, + confidence_level: str, + exclude_tests: bool, + skip_ids: List[str] + ) -> Dict[str, Any]: + """ + Run Bandit on the workspace. + + Args: + workspace: Path to workspace + severity_level: Minimum severity to report + confidence_level: Minimum confidence to report + exclude_tests: Whether to exclude test files + skip_ids: List of test IDs to skip + + Returns: + Bandit JSON output as dict + """ + try: + # Build bandit command + cmd = [ + "bandit", + "-r", str(workspace), + "-f", "json", + "-ll", # Report all findings (we'll filter later) + ] + + # Add exclude patterns for test files + if exclude_tests: + cmd.extend(["-x", "*/test_*.py,*/tests/*,*_test.py"]) + + # Add skip IDs if specified + if skip_ids: + cmd.extend(["-s", ",".join(skip_ids)]) + + logger.info(f"Running Bandit on: {workspace}") + process = await asyncio.create_subprocess_exec( + *cmd, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE + ) + + stdout, stderr = await process.communicate() + + # Bandit returns non-zero if issues found, which is expected + if process.returncode not in [0, 1]: + logger.error(f"Bandit failed: {stderr.decode()}") + return {"results": []} + + # Parse JSON output + result = json.loads(stdout.decode()) + return result + + except Exception as e: + logger.error(f"Error running Bandit: {e}") + return {"results": []} + + def _should_include_finding( + self, + issue: Dict[str, Any], + min_severity: str, + min_confidence: str + ) -> bool: + """ + Determine if a Bandit issue should be included based on severity/confidence. + + Args: + issue: Bandit issue dict + min_severity: Minimum severity threshold + min_confidence: Minimum confidence threshold + + Returns: + True if issue should be included + """ + severity_order = ["low", "medium", "high"] + issue_severity = issue.get("issue_severity", "LOW").lower() + issue_confidence = issue.get("issue_confidence", "LOW").lower() + + severity_meets_threshold = severity_order.index(issue_severity) >= severity_order.index(min_severity) + confidence_meets_threshold = severity_order.index(issue_confidence) >= severity_order.index(min_confidence) + + return severity_meets_threshold and confidence_meets_threshold + + def _convert_to_findings( + self, + bandit_result: Dict[str, Any], + workspace: Path, + min_severity: str, + min_confidence: str + ) -> List[ModuleFinding]: + """ + Convert Bandit results to ModuleFindings. + + Args: + bandit_result: Bandit JSON output + workspace: Workspace path for relative paths + min_severity: Minimum severity to include + min_confidence: Minimum confidence to include + + Returns: + List of ModuleFindings + """ + findings = [] + + for issue in bandit_result.get("results", []): + # Filter by severity and confidence + if not self._should_include_finding(issue, min_severity, min_confidence): + continue + + # Extract issue details + test_id = issue.get("test_id", "B000") + test_name = issue.get("test_name", "unknown") + issue_text = issue.get("issue_text", "No description") + severity = self.SEVERITY_MAP.get(issue.get("issue_severity", "LOW"), "low") + + # File location + filename = issue.get("filename", "") + line_number = issue.get("line_number", 0) + code = issue.get("code", "") + + # Try to get relative path + try: + file_path = Path(filename) + rel_path = file_path.relative_to(workspace) + except (ValueError, TypeError): + rel_path = Path(filename).name + + # Create finding + finding = self.create_finding( + title=f"{test_name} ({test_id})", + description=issue_text, + severity=severity, + category="security-issue", + file_path=str(rel_path), + line_start=line_number, + line_end=line_number, + code_snippet=code.strip() if code else None, + recommendation=f"Review and fix the security issue identified by Bandit test {test_id}", + metadata={ + "test_id": test_id, + "test_name": test_name, + "confidence": issue.get("issue_confidence", "LOW").lower(), + "cwe": issue.get("issue_cwe", {}).get("id") if issue.get("issue_cwe") else None, + "more_info": issue.get("more_info", "") + } + ) + findings.append(finding) + + return findings + + async def execute(self, config: Dict[str, Any], workspace: Path) -> ModuleResult: + """ + Execute the Bandit analyzer module. + + Args: + config: Module configuration + workspace: Path to workspace + + Returns: + ModuleResult with security findings + """ + start_time = time.time() + metadata = self.get_metadata() + + # Validate inputs + self.validate_config(config) + self.validate_workspace(workspace) + + # Get configuration + severity_level = config.get("severity_level", "low") + confidence_level = config.get("confidence_level", "medium") + exclude_tests = config.get("exclude_tests", True) + skip_ids = config.get("skip_ids", []) + + # Run Bandit + logger.info("Starting Bandit analysis...") + bandit_result = await self._run_bandit( + workspace, + severity_level, + confidence_level, + exclude_tests, + skip_ids + ) + + # Convert to findings + findings = self._convert_to_findings( + bandit_result, + workspace, + severity_level, + confidence_level + ) + + # Calculate summary + severity_counts = {} + for finding in findings: + sev = finding.severity + severity_counts[sev] = severity_counts.get(sev, 0) + 1 + + execution_time = time.time() - start_time + + return ModuleResult( + module=metadata.name, + version=metadata.version, + status="success", + execution_time=execution_time, + findings=findings, + summary={ + "total_issues": len(findings), + "by_severity": severity_counts, + "files_analyzed": len(set(f.file_path for f in findings if f.file_path)) + }, + metadata={ + "bandit_version": bandit_result.get("generated_at", "unknown"), + "metrics": bandit_result.get("metrics", {}) + } + ) diff --git a/backend/toolbox/modules/analyzer/mypy_analyzer.py b/backend/toolbox/modules/analyzer/mypy_analyzer.py new file mode 100644 index 0000000..9d3e39f --- /dev/null +++ b/backend/toolbox/modules/analyzer/mypy_analyzer.py @@ -0,0 +1,269 @@ +""" +Mypy Analyzer Module - Analyzes Python code for type safety issues using Mypy +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +import asyncio +import logging +import re +import time +from pathlib import Path +from typing import Dict, Any, List + +try: + from toolbox.modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding +except ImportError: + try: + from modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding + except ImportError: + from src.toolbox.modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding + +logger = logging.getLogger(__name__) + + +class MypyAnalyzer(BaseModule): + """ + Analyzes Python code for type safety issues using Mypy. + + This module: + - Runs Mypy type checker on Python files + - Detects type errors and inconsistencies + - Reports findings with configurable strictness + """ + + # Map Mypy error codes to severity + ERROR_SEVERITY_MAP = { + "error": "medium", + "note": "info" + } + + def get_metadata(self) -> ModuleMetadata: + """Get module metadata""" + return ModuleMetadata( + name="mypy_analyzer", + version="1.0.0", + description="Analyzes Python code for type safety issues using Mypy", + author="FuzzForge Team", + category="analyzer", + tags=["python", "type-checking", "mypy", "sast"], + input_schema={ + "strict_mode": { + "type": "boolean", + "description": "Enable strict type checking", + "default": False + }, + "ignore_missing_imports": { + "type": "boolean", + "description": "Ignore errors about missing imports", + "default": True + }, + "follow_imports": { + "type": "string", + "enum": ["normal", "silent", "skip", "error"], + "description": "How to handle imports", + "default": "silent" + } + }, + output_schema={ + "findings": { + "type": "array", + "description": "List of type errors found by Mypy" + } + }, + requires_workspace=True + ) + + def validate_config(self, config: Dict[str, Any]) -> bool: + """Validate module configuration""" + follow_imports = config.get("follow_imports", "silent") + if follow_imports not in ["normal", "silent", "skip", "error"]: + raise ValueError("follow_imports must be one of: normal, silent, skip, error") + + return True + + async def _run_mypy( + self, + workspace: Path, + strict_mode: bool, + ignore_missing_imports: bool, + follow_imports: str + ) -> str: + """ + Run Mypy on the workspace. + + Args: + workspace: Path to workspace + strict_mode: Enable strict checking + ignore_missing_imports: Ignore missing import errors + follow_imports: How to handle imports + + Returns: + Mypy output as string + """ + try: + # Build mypy command + cmd = [ + "mypy", + str(workspace), + "--show-column-numbers", + "--no-error-summary", + f"--follow-imports={follow_imports}" + ] + + if strict_mode: + cmd.append("--strict") + + if ignore_missing_imports: + cmd.append("--ignore-missing-imports") + + logger.info(f"Running Mypy on: {workspace}") + process = await asyncio.create_subprocess_exec( + *cmd, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE + ) + + stdout, stderr = await process.communicate() + + # Mypy returns non-zero if errors found, which is expected + output = stdout.decode() + return output + + except Exception as e: + logger.error(f"Error running Mypy: {e}") + return "" + + def _parse_mypy_output(self, output: str, workspace: Path) -> List[ModuleFinding]: + """ + Parse Mypy output and convert to findings. + + Mypy output format: + file.py:10:5: error: Incompatible return value type [return-value] + file.py:15: note: See https://... + + Args: + output: Mypy stdout + workspace: Workspace path for relative paths + + Returns: + List of ModuleFindings + """ + findings = [] + + # Regex to parse mypy output lines + # Format: filename:line:column: level: message [error-code] + pattern = r'^(.+?):(\d+)(?::(\d+))?: (error|note): (.+?)(?:\s+\[([^\]]+)\])?$' + + for line in output.splitlines(): + match = re.match(pattern, line.strip()) + if not match: + continue + + filename, line_num, column, level, message, error_code = match.groups() + + # Convert to relative path + try: + file_path = Path(filename) + rel_path = file_path.relative_to(workspace) + except (ValueError, TypeError): + rel_path = Path(filename).name + + # Skip if it's just a note (unless it's a standalone note) + if level == "note" and not error_code: + continue + + # Map severity + severity = self.ERROR_SEVERITY_MAP.get(level, "medium") + + # Create finding + title = f"Type error: {error_code or 'type-issue'}" + description = message + + finding = self.create_finding( + title=title, + description=description, + severity=severity, + category="type-error", + file_path=str(rel_path), + line_start=int(line_num), + line_end=int(line_num), + recommendation="Review and fix the type inconsistency or add appropriate type annotations", + metadata={ + "error_code": error_code or "unknown", + "column": int(column) if column else None, + "level": level + } + ) + findings.append(finding) + + return findings + + async def execute(self, config: Dict[str, Any], workspace: Path) -> ModuleResult: + """ + Execute the Mypy analyzer module. + + Args: + config: Module configuration + workspace: Path to workspace + + Returns: + ModuleResult with type checking findings + """ + start_time = time.time() + metadata = self.get_metadata() + + # Validate inputs + self.validate_config(config) + self.validate_workspace(workspace) + + # Get configuration + strict_mode = config.get("strict_mode", False) + ignore_missing_imports = config.get("ignore_missing_imports", True) + follow_imports = config.get("follow_imports", "silent") + + # Run Mypy + logger.info("Starting Mypy analysis...") + mypy_output = await self._run_mypy( + workspace, + strict_mode, + ignore_missing_imports, + follow_imports + ) + + # Parse output to findings + findings = self._parse_mypy_output(mypy_output, workspace) + + # Calculate summary + error_code_counts = {} + for finding in findings: + code = finding.metadata.get("error_code", "unknown") + error_code_counts[code] = error_code_counts.get(code, 0) + 1 + + execution_time = time.time() - start_time + + return ModuleResult( + module=metadata.name, + version=metadata.version, + status="success", + execution_time=execution_time, + findings=findings, + summary={ + "total_errors": len(findings), + "by_error_code": error_code_counts, + "files_with_errors": len(set(f.file_path for f in findings if f.file_path)) + }, + metadata={ + "strict_mode": strict_mode, + "ignore_missing_imports": ignore_missing_imports + } + ) diff --git a/backend/toolbox/modules/android/__init__.py b/backend/toolbox/modules/android/__init__.py new file mode 100644 index 0000000..ef2c74c --- /dev/null +++ b/backend/toolbox/modules/android/__init__.py @@ -0,0 +1,31 @@ +""" +Android Security Analysis Modules + +Modules for Android application security testing: +- JadxDecompiler: APK decompilation using Jadx +- MobSFScanner: Mobile security analysis using MobSF +- OpenGrepAndroid: Static analysis using OpenGrep/Semgrep with Android-specific rules +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +from .jadx_decompiler import JadxDecompiler +from .opengrep_android import OpenGrepAndroid + +# MobSF is optional (not available on ARM64 platform) +try: + from .mobsf_scanner import MobSFScanner + __all__ = ["JadxDecompiler", "MobSFScanner", "OpenGrepAndroid"] +except ImportError: + # MobSF dependencies not available (e.g., ARM64 platform) + MobSFScanner = None + __all__ = ["JadxDecompiler", "OpenGrepAndroid"] diff --git a/backend/toolbox/modules/android/custom_rules/clipboard-sensitive-data.yaml b/backend/toolbox/modules/android/custom_rules/clipboard-sensitive-data.yaml new file mode 100644 index 0000000..df7944e --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/clipboard-sensitive-data.yaml @@ -0,0 +1,15 @@ +rules: + - id: clipboard-sensitive-data + severity: WARNING + languages: [java] + message: "Sensitive data may be copied to the clipboard." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + category: security + area: clipboard + verification-level: [L1] + paths: + include: + - "**/*.java" + pattern: "$CLIPBOARD.setPrimaryClip($CLIP)" diff --git a/backend/toolbox/modules/android/custom_rules/hardcoded-secrets.yaml b/backend/toolbox/modules/android/custom_rules/hardcoded-secrets.yaml new file mode 100644 index 0000000..c353c96 --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/hardcoded-secrets.yaml @@ -0,0 +1,23 @@ +rules: + - id: hardcoded-secrets + severity: WARNING + languages: [java] + message: "Possible hardcoded secret found in variable '$NAME'." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + owasp-mobile: M2 + category: secrets + verification-level: [L1] + paths: + include: + - "**/*.java" + patterns: + - pattern-either: + - pattern: 'String $NAME = "$VAL";' + - pattern: 'final String $NAME = "$VAL";' + - pattern: 'private String $NAME = "$VAL";' + - pattern: 'public static String $NAME = "$VAL";' + - pattern: 'static final String $NAME = "$VAL";' + - pattern-regex: "$NAME =~ /(?i).*(api|key|token|secret|pass|auth|session|bearer|access|private).*/" + diff --git a/backend/toolbox/modules/android/custom_rules/insecure-data-storage.yaml b/backend/toolbox/modules/android/custom_rules/insecure-data-storage.yaml new file mode 100644 index 0000000..c22546d --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/insecure-data-storage.yaml @@ -0,0 +1,18 @@ +rules: + - id: insecure-data-storage + severity: WARNING + languages: [java] + message: "Potential insecure data storage (external storage)." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + owasp-mobile: M2 + category: security + area: storage + verification-level: [L1] + paths: + include: + - "**/*.java" + pattern-either: + - pattern: "$CTX.openFileOutput($NAME, $MODE)" + - pattern: "Environment.getExternalStorageDirectory()" diff --git a/backend/toolbox/modules/android/custom_rules/insecure-deeplink.yaml b/backend/toolbox/modules/android/custom_rules/insecure-deeplink.yaml new file mode 100644 index 0000000..4be31ad --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/insecure-deeplink.yaml @@ -0,0 +1,16 @@ +rules: + - id: insecure-deeplink + severity: WARNING + languages: [xml] + message: "Potential insecure deeplink found in intent-filter." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + category: component + area: manifest + verification-level: [L1] + paths: + include: + - "**/AndroidManifest.xml" + pattern: | + diff --git a/backend/toolbox/modules/android/custom_rules/insecure-logging.yaml b/backend/toolbox/modules/android/custom_rules/insecure-logging.yaml new file mode 100644 index 0000000..f36f2a7 --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/insecure-logging.yaml @@ -0,0 +1,21 @@ +rules: + - id: insecure-logging + severity: WARNING + languages: [java] + message: "Sensitive data logged via Android Log API." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + owasp-mobile: M2 + category: logging + verification-level: [L1] + paths: + include: + - "**/*.java" + patterns: + - pattern-either: + - pattern: "Log.d($TAG, $MSG)" + - pattern: "Log.e($TAG, $MSG)" + - pattern: "System.out.println($MSG)" + - pattern-regex: "$MSG =~ /(?i).*(password|token|secret|api|auth|session).*/" + diff --git a/backend/toolbox/modules/android/custom_rules/intent-redirection.yaml b/backend/toolbox/modules/android/custom_rules/intent-redirection.yaml new file mode 100644 index 0000000..ade522a --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/intent-redirection.yaml @@ -0,0 +1,15 @@ +rules: + - id: intent-redirection + severity: WARNING + languages: [java] + message: "Potential intent redirection: using getIntent().getExtras() without validation." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + category: intent + area: intercomponent + verification-level: [L1] + paths: + include: + - "**/*.java" + pattern: "$ACT.getIntent().getExtras()" diff --git a/backend/toolbox/modules/android/custom_rules/sensitive_data_sharedPreferences.yaml b/backend/toolbox/modules/android/custom_rules/sensitive_data_sharedPreferences.yaml new file mode 100644 index 0000000..4f8f28f --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/sensitive_data_sharedPreferences.yaml @@ -0,0 +1,18 @@ +rules: + - id: sensitive-data-in-shared-preferences + severity: WARNING + languages: [java] + message: "Sensitive data may be stored in SharedPreferences. Please review the key '$KEY'." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + owasp-mobile: M2 + category: security + area: storage + verification-level: [L1] + paths: + include: + - "**/*.java" + patterns: + - pattern: "$EDITOR.putString($KEY, $VAL);" + - pattern-regex: "$KEY =~ /(?i).*(username|password|pass|token|auth_token|api_key|secret|sessionid|email).*/" diff --git a/backend/toolbox/modules/android/custom_rules/sqlite-injection.yaml b/backend/toolbox/modules/android/custom_rules/sqlite-injection.yaml new file mode 100644 index 0000000..5d07e22 --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/sqlite-injection.yaml @@ -0,0 +1,21 @@ +rules: + - id: sqlite-injection + severity: ERROR + languages: [java] + message: "Possible SQL injection: concatenated input in rawQuery or execSQL." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + owasp-mobile: M7 + category: injection + area: database + verification-level: [L1] + paths: + include: + - "**/*.java" + patterns: + - pattern-either: + - pattern: "$DB.rawQuery($QUERY, ...)" + - pattern: "$DB.execSQL($QUERY)" + - pattern-regex: "$QUERY =~ /.*\".*\".*\\+.*/" + diff --git a/backend/toolbox/modules/android/custom_rules/vulnerable-activity.yaml b/backend/toolbox/modules/android/custom_rules/vulnerable-activity.yaml new file mode 100644 index 0000000..0cef4fc --- /dev/null +++ b/backend/toolbox/modules/android/custom_rules/vulnerable-activity.yaml @@ -0,0 +1,16 @@ +rules: + - id: vulnerable-activity + severity: WARNING + languages: [xml] + message: "Activity exported without permission." + metadata: + authors: + - Guerric ELOI (FuzzingLabs) + category: component + area: manifest + verification-level: [L1] + paths: + include: + - "**/AndroidManifest.xml" + pattern: | + ModuleMetadata: + return ModuleMetadata( + name="jadx_decompiler", + version="1.5.0", + description="Android APK decompilation using Jadx - converts DEX bytecode to Java source", + author="FuzzForge Team", + category="android", + tags=["android", "jadx", "decompilation", "reverse", "apk"], + input_schema={ + "type": "object", + "properties": { + "apk_path": { + "type": "string", + "description": "Path to the APK to decompile (absolute or relative to workspace)", + }, + "output_dir": { + "type": "string", + "description": "Directory (relative to workspace) where Jadx output should be written", + "default": "jadx_output", + }, + "overwrite": { + "type": "boolean", + "description": "Overwrite existing output directory if present", + "default": True, + }, + "threads": { + "type": "integer", + "description": "Number of Jadx decompilation threads", + "default": 4, + "minimum": 1, + "maximum": 32, + }, + "decompiler_args": { + "type": "array", + "items": {"type": "string"}, + "description": "Additional arguments passed directly to Jadx", + "default": [], + }, + }, + "required": ["apk_path"], + }, + output_schema={ + "type": "object", + "properties": { + "output_dir": { + "type": "string", + "description": "Path to decompiled output directory", + }, + "source_dir": { + "type": "string", + "description": "Path to decompiled Java sources", + }, + "resource_dir": { + "type": "string", + "description": "Path to extracted resources", + }, + "java_files": { + "type": "integer", + "description": "Number of Java files decompiled", + }, + }, + }, + requires_workspace=True, + ) + + def validate_config(self, config: Dict[str, Any]) -> bool: + """Validate module configuration""" + apk_path = config.get("apk_path") + if not apk_path: + raise ValueError("'apk_path' must be provided for Jadx decompilation") + + threads = config.get("threads", 4) + if not isinstance(threads, int) or threads < 1 or threads > 32: + raise ValueError("threads must be between 1 and 32") + + return True + + async def execute(self, config: Dict[str, Any], workspace: Path) -> ModuleResult: + """ + Execute Jadx decompilation on an APK file. + + Args: + config: Configuration dict with apk_path, output_dir, etc. + workspace: Workspace directory path + + Returns: + ModuleResult with decompilation summary and metadata + """ + self.start_timer() + + try: + self.validate_config(config) + self.validate_workspace(workspace) + + workspace = workspace.resolve() + + # Resolve APK path + apk_path = Path(config["apk_path"]) + if not apk_path.is_absolute(): + apk_path = (workspace / apk_path).resolve() + + if not apk_path.exists(): + raise ValueError(f"APK not found: {apk_path}") + + if apk_path.is_dir(): + raise ValueError(f"APK path must be a file, not a directory: {apk_path}") + + logger.info(f"Decompiling APK: {apk_path}") + + # Resolve output directory + output_dir = Path(config.get("output_dir", "jadx_output")) + if not output_dir.is_absolute(): + output_dir = (workspace / output_dir).resolve() + + # Handle existing output directory + if output_dir.exists(): + if config.get("overwrite", True): + logger.info(f"Removing existing output directory: {output_dir}") + shutil.rmtree(output_dir) + else: + raise ValueError( + f"Output directory already exists: {output_dir}. Set overwrite=true to replace it." + ) + + output_dir.mkdir(parents=True, exist_ok=True) + + # Build Jadx command + threads = str(config.get("threads", 4)) + extra_args = config.get("decompiler_args", []) or [] + + cmd = [ + "jadx", + "--threads-count", + threads, + "--deobf", # Deobfuscate code + "--output-dir", + str(output_dir), + ] + cmd.extend(extra_args) + cmd.append(str(apk_path)) + + logger.info(f"Running Jadx: {' '.join(cmd)}") + + # Execute Jadx + process = await asyncio.create_subprocess_exec( + *cmd, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE, + cwd=str(workspace), + ) + + stdout, stderr = await process.communicate() + stdout_str = stdout.decode(errors="ignore") if stdout else "" + stderr_str = stderr.decode(errors="ignore") if stderr else "" + + if stdout_str: + logger.debug(f"Jadx stdout: {stdout_str[:200]}...") + if stderr_str: + logger.debug(f"Jadx stderr: {stderr_str[:200]}...") + + if process.returncode != 0: + error_output = stderr_str or stdout_str or "No error output" + raise RuntimeError( + f"Jadx failed with exit code {process.returncode}: {error_output[:500]}" + ) + + # Verify output structure + source_dir = output_dir / "sources" + resource_dir = output_dir / "resources" + + if not source_dir.exists(): + logger.warning( + f"Jadx sources directory not found at expected path: {source_dir}" + ) + # Use output_dir as fallback + source_dir = output_dir + + # Count decompiled Java files + java_files = 0 + if source_dir.exists(): + java_files = sum(1 for _ in source_dir.rglob("*.java")) + logger.info(f"Decompiled {java_files} Java files") + + # Log sample files for debugging + sample_files = [] + for idx, file_path in enumerate(source_dir.rglob("*.java")): + sample_files.append(str(file_path.relative_to(workspace))) + if idx >= 4: + break + if sample_files: + logger.debug(f"Sample Java files: {sample_files}") + + # Create summary + summary = { + "output_dir": str(output_dir), + "source_dir": str(source_dir if source_dir.exists() else output_dir), + "resource_dir": str( + resource_dir if resource_dir.exists() else output_dir + ), + "java_files": java_files, + "apk_name": apk_path.name, + "apk_size_bytes": apk_path.stat().st_size, + } + + metadata = { + "apk_path": str(apk_path), + "output_dir": str(output_dir), + "source_dir": summary["source_dir"], + "resource_dir": summary["resource_dir"], + "threads": threads, + "decompiler": "jadx", + "decompiler_version": "1.5.0", + } + + logger.info( + f"✓ Jadx decompilation completed: {java_files} Java files generated" + ) + + return self.create_result( + findings=[], # Jadx doesn't generate findings, only decompiles + status="success", + summary=summary, + metadata=metadata, + ) + + except Exception as exc: + logger.error(f"Jadx decompilation failed: {exc}", exc_info=True) + return self.create_result( + findings=[], + status="failed", + error=str(exc), + metadata={"decompiler": "jadx", "apk_path": config.get("apk_path")}, + ) diff --git a/backend/toolbox/modules/android/mobsf_scanner.py b/backend/toolbox/modules/android/mobsf_scanner.py new file mode 100644 index 0000000..3b16e1b --- /dev/null +++ b/backend/toolbox/modules/android/mobsf_scanner.py @@ -0,0 +1,437 @@ +""" +MobSF Scanner Module + +Mobile Security Framework (MobSF) integration for comprehensive Android app security analysis. +Performs static analysis on APK files including permissions, manifest analysis, code analysis, and behavior checks. +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +import logging +import os +from collections import Counter +from pathlib import Path +from typing import Dict, Any, List +import aiohttp + +try: + from toolbox.modules.base import BaseModule, ModuleMetadata, ModuleFinding, ModuleResult +except ImportError: + try: + from modules.base import BaseModule, ModuleMetadata, ModuleFinding, ModuleResult + except ImportError: + from src.toolbox.modules.base import BaseModule, ModuleMetadata, ModuleFinding, ModuleResult + +logger = logging.getLogger(__name__) + + +class MobSFScanner(BaseModule): + """Mobile Security Framework (MobSF) scanner module for Android applications""" + + SEVERITY_MAP = { + "dangerous": "critical", + "high": "high", + "warning": "medium", + "medium": "medium", + "low": "low", + "info": "low", + "secure": "low", + } + + def get_metadata(self) -> ModuleMetadata: + return ModuleMetadata( + name="mobsf_scanner", + version="3.9.7", + description="Comprehensive Android security analysis using Mobile Security Framework (MobSF)", + author="FuzzForge Team", + category="android", + tags=["mobile", "android", "mobsf", "sast", "scanner", "security"], + input_schema={ + "type": "object", + "properties": { + "mobsf_url": { + "type": "string", + "description": "MobSF server URL", + "default": "http://localhost:8877", + }, + "file_path": { + "type": "string", + "description": "Path to the APK file to scan (absolute or relative to workspace)", + }, + "api_key": { + "type": "string", + "description": "MobSF API key (if not provided, will try MOBSF_API_KEY env var)", + "default": None, + }, + "rescan": { + "type": "boolean", + "description": "Force rescan even if file was previously analyzed", + "default": False, + }, + }, + "required": ["file_path"], + }, + output_schema={ + "type": "object", + "properties": { + "findings": { + "type": "array", + "description": "Security findings from MobSF analysis" + }, + "scan_hash": {"type": "string"}, + "total_findings": {"type": "integer"}, + "severity_counts": {"type": "object"}, + } + }, + requires_workspace=True, + ) + + def validate_config(self, config: Dict[str, Any]) -> bool: + """Validate module configuration""" + if "mobsf_url" in config and not isinstance(config["mobsf_url"], str): + raise ValueError("mobsf_url must be a string") + + file_path = config.get("file_path") + if not file_path: + raise ValueError("file_path is required for MobSF scanning") + + return True + + async def execute(self, config: Dict[str, Any], workspace: Path) -> ModuleResult: + """ + Execute MobSF security analysis on an APK file. + + Args: + config: Configuration dict with file_path, mobsf_url, api_key + workspace: Workspace directory path + + Returns: + ModuleResult with security findings from MobSF + """ + self.start_timer() + + try: + self.validate_config(config) + self.validate_workspace(workspace) + + # Get configuration + mobsf_url = config.get("mobsf_url", "http://localhost:8877") + file_path_str = config["file_path"] + rescan = config.get("rescan", False) + + # Get API key from config or environment + api_key = config.get("api_key") or os.environ.get("MOBSF_API_KEY", "") + if not api_key: + logger.warning("No MobSF API key provided. Some functionality may be limited.") + + # Resolve APK file path + file_path = Path(file_path_str) + if not file_path.is_absolute(): + file_path = (workspace / file_path).resolve() + + if not file_path.exists(): + raise FileNotFoundError(f"APK file not found: {file_path}") + + if not file_path.is_file(): + raise ValueError(f"APK path must be a file: {file_path}") + + logger.info(f"Starting MobSF scan of APK: {file_path}") + + # Upload and scan APK + scan_hash = await self._upload_file(mobsf_url, file_path, api_key) + logger.info(f"APK uploaded to MobSF with hash: {scan_hash}") + + # Start scan + await self._start_scan(mobsf_url, scan_hash, api_key, rescan=rescan) + logger.info(f"MobSF scan completed for hash: {scan_hash}") + + # Get JSON results + scan_results = await self._get_json_results(mobsf_url, scan_hash, api_key) + + # Parse results into findings + findings = self._parse_scan_results(scan_results, file_path) + + # Create summary + summary = self._create_summary(findings, scan_hash) + + logger.info(f"✓ MobSF scan completed: {len(findings)} findings") + + return self.create_result( + findings=findings, + status="success", + summary=summary, + metadata={ + "tool": "mobsf", + "tool_version": "3.9.7", + "scan_hash": scan_hash, + "apk_file": str(file_path), + "mobsf_url": mobsf_url, + } + ) + + except Exception as exc: + logger.error(f"MobSF scanner failed: {exc}", exc_info=True) + return self.create_result( + findings=[], + status="failed", + error=str(exc), + metadata={"tool": "mobsf", "file_path": config.get("file_path")} + ) + + async def _upload_file(self, mobsf_url: str, file_path: Path, api_key: str) -> str: + """ + Upload APK file to MobSF server. + + Returns: + Scan hash for the uploaded file + """ + headers = {'X-Mobsf-Api-Key': api_key} if api_key else {} + + # Create multipart form data + filename = file_path.name + + async with aiohttp.ClientSession() as session: + with open(file_path, 'rb') as f: + data = aiohttp.FormData() + data.add_field('file', + f, + filename=filename, + content_type='application/vnd.android.package-archive') + + async with session.post( + f"{mobsf_url}/api/v1/upload", + headers=headers, + data=data, + timeout=aiohttp.ClientTimeout(total=300) + ) as response: + if response.status != 200: + error_text = await response.text() + raise Exception(f"Failed to upload file to MobSF: {error_text}") + + result = await response.json() + scan_hash = result.get('hash') + if not scan_hash: + raise Exception(f"MobSF upload failed: {result}") + + return scan_hash + + async def _start_scan(self, mobsf_url: str, scan_hash: str, api_key: str, rescan: bool = False) -> Dict[str, Any]: + """ + Start MobSF scan for uploaded file. + + Returns: + Scan result dictionary + """ + headers = {'X-Mobsf-Api-Key': api_key} if api_key else {} + data = { + 'hash': scan_hash, + 're_scan': '1' if rescan else '0' + } + + async with aiohttp.ClientSession() as session: + async with session.post( + f"{mobsf_url}/api/v1/scan", + headers=headers, + data=data, + timeout=aiohttp.ClientTimeout(total=600) # 10 minutes for scan + ) as response: + if response.status != 200: + error_text = await response.text() + raise Exception(f"MobSF scan failed: {error_text}") + + result = await response.json() + return result + + async def _get_json_results(self, mobsf_url: str, scan_hash: str, api_key: str) -> Dict[str, Any]: + """ + Retrieve JSON scan results from MobSF. + + Returns: + Scan results dictionary + """ + headers = {'X-Mobsf-Api-Key': api_key} if api_key else {} + data = {'hash': scan_hash} + + async with aiohttp.ClientSession() as session: + async with session.post( + f"{mobsf_url}/api/v1/report_json", + headers=headers, + data=data, + timeout=aiohttp.ClientTimeout(total=60) + ) as response: + if response.status != 200: + error_text = await response.text() + raise Exception(f"Failed to retrieve MobSF results: {error_text}") + + return await response.json() + + def _parse_scan_results(self, scan_data: Dict[str, Any], apk_path: Path) -> List[ModuleFinding]: + """Parse MobSF JSON results into standardized findings""" + findings = [] + + # Parse permissions + if 'permissions' in scan_data: + for perm_name, perm_attrs in scan_data['permissions'].items(): + if isinstance(perm_attrs, dict): + severity = self.SEVERITY_MAP.get( + perm_attrs.get('status', '').lower(), 'low' + ) + + finding = self.create_finding( + title=f"Android Permission: {perm_name}", + description=perm_attrs.get('description', 'No description'), + severity=severity, + category="android-permission", + metadata={ + 'permission': perm_name, + 'status': perm_attrs.get('status'), + 'info': perm_attrs.get('info'), + 'tool': 'mobsf', + } + ) + findings.append(finding) + + # Parse manifest analysis + if 'manifest_analysis' in scan_data: + manifest_findings = scan_data['manifest_analysis'].get('manifest_findings', []) + for item in manifest_findings: + if isinstance(item, dict): + severity = self.SEVERITY_MAP.get(item.get('severity', '').lower(), 'medium') + + finding = self.create_finding( + title=item.get('title') or item.get('name') or "Manifest Issue", + description=item.get('description', 'No description'), + severity=severity, + category="android-manifest", + metadata={ + 'rule': item.get('rule'), + 'tool': 'mobsf', + } + ) + findings.append(finding) + + # Parse code analysis + if 'code_analysis' in scan_data: + code_findings = scan_data['code_analysis'].get('findings', {}) + for finding_name, finding_data in code_findings.items(): + if isinstance(finding_data, dict): + metadata_dict = finding_data.get('metadata', {}) + severity = self.SEVERITY_MAP.get( + metadata_dict.get('severity', '').lower(), 'medium' + ) + + # MobSF returns 'files' as a dict: {filename: line_numbers} + files_dict = finding_data.get('files', {}) + + # Create a finding for each affected file + if isinstance(files_dict, dict) and files_dict: + for file_path, line_numbers in files_dict.items(): + finding = self.create_finding( + title=finding_name, + description=metadata_dict.get('description', 'No description'), + severity=severity, + category="android-code-analysis", + file_path=file_path, + line_number=line_numbers, # Can be string like "28" or "65,81" + metadata={ + 'cwe': metadata_dict.get('cwe'), + 'owasp': metadata_dict.get('owasp'), + 'masvs': metadata_dict.get('masvs'), + 'cvss': metadata_dict.get('cvss'), + 'ref': metadata_dict.get('ref'), + 'line_numbers': line_numbers, + 'tool': 'mobsf', + } + ) + findings.append(finding) + else: + # Fallback: create one finding without file info + finding = self.create_finding( + title=finding_name, + description=metadata_dict.get('description', 'No description'), + severity=severity, + category="android-code-analysis", + metadata={ + 'cwe': metadata_dict.get('cwe'), + 'owasp': metadata_dict.get('owasp'), + 'masvs': metadata_dict.get('masvs'), + 'cvss': metadata_dict.get('cvss'), + 'ref': metadata_dict.get('ref'), + 'tool': 'mobsf', + } + ) + findings.append(finding) + + # Parse behavior analysis + if 'behaviour' in scan_data: + for key, value in scan_data['behaviour'].items(): + if isinstance(value, dict): + metadata_dict = value.get('metadata', {}) + labels = metadata_dict.get('label', []) + label = labels[0] if labels else 'Unknown Behavior' + + severity = self.SEVERITY_MAP.get( + metadata_dict.get('severity', '').lower(), 'medium' + ) + + # MobSF returns 'files' as a dict: {filename: line_numbers} + files_dict = value.get('files', {}) + + # Create a finding for each affected file + if isinstance(files_dict, dict) and files_dict: + for file_path, line_numbers in files_dict.items(): + finding = self.create_finding( + title=f"Behavior: {label}", + description=metadata_dict.get('description', 'No description'), + severity=severity, + category="android-behavior", + file_path=file_path, + line_number=line_numbers, + metadata={ + 'line_numbers': line_numbers, + 'behavior_key': key, + 'tool': 'mobsf', + } + ) + findings.append(finding) + else: + # Fallback: create one finding without file info + finding = self.create_finding( + title=f"Behavior: {label}", + description=metadata_dict.get('description', 'No description'), + severity=severity, + category="android-behavior", + metadata={ + 'behavior_key': key, + 'tool': 'mobsf', + } + ) + findings.append(finding) + + logger.debug(f"Parsed {len(findings)} findings from MobSF results") + return findings + + def _create_summary(self, findings: List[ModuleFinding], scan_hash: str) -> Dict[str, Any]: + """Create analysis summary""" + severity_counter = Counter() + category_counter = Counter() + + for finding in findings: + severity_counter[finding.severity] += 1 + category_counter[finding.category] += 1 + + return { + "scan_hash": scan_hash, + "total_findings": len(findings), + "severity_counts": dict(severity_counter), + "category_counts": dict(category_counter), + } diff --git a/backend/toolbox/modules/android/opengrep_android.py b/backend/toolbox/modules/android/opengrep_android.py new file mode 100644 index 0000000..01e32c4 --- /dev/null +++ b/backend/toolbox/modules/android/opengrep_android.py @@ -0,0 +1,440 @@ +""" +OpenGrep Android Static Analysis Module + +Pattern-based static analysis for Android applications using OpenGrep/Semgrep +with Android-specific security rules. +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +import asyncio +import json +import logging +from pathlib import Path +from typing import Dict, Any, List + +try: + from toolbox.modules.base import BaseModule, ModuleMetadata, ModuleFinding, ModuleResult +except ImportError: + try: + from modules.base import BaseModule, ModuleMetadata, ModuleFinding, ModuleResult + except ImportError: + from src.toolbox.modules.base import BaseModule, ModuleMetadata, ModuleFinding, ModuleResult + +logger = logging.getLogger(__name__) + + +class OpenGrepAndroid(BaseModule): + """OpenGrep static analysis module specialized for Android security""" + + def get_metadata(self) -> ModuleMetadata: + """Get module metadata""" + return ModuleMetadata( + name="opengrep_android", + version="1.45.0", + description="Android-focused static analysis using OpenGrep/Semgrep with custom security rules for Java/Kotlin", + author="FuzzForge Team", + category="android", + tags=["sast", "android", "opengrep", "semgrep", "java", "kotlin", "security"], + input_schema={ + "type": "object", + "properties": { + "config": { + "type": "string", + "enum": ["auto", "p/security-audit", "p/owasp-top-ten", "p/cwe-top-25"], + "default": "auto", + "description": "Rule configuration to use" + }, + "custom_rules_path": { + "type": "string", + "description": "Path to a directory containing custom OpenGrep rules (Android-specific rules recommended)", + "default": None, + }, + "languages": { + "type": "array", + "items": {"type": "string"}, + "description": "Specific languages to analyze (defaults to java, kotlin for Android)", + "default": ["java", "kotlin"], + }, + "include_patterns": { + "type": "array", + "items": {"type": "string"}, + "description": "File patterns to include", + "default": [], + }, + "exclude_patterns": { + "type": "array", + "items": {"type": "string"}, + "description": "File patterns to exclude", + "default": [], + }, + "max_target_bytes": { + "type": "integer", + "default": 1000000, + "description": "Maximum file size to analyze (bytes)" + }, + "timeout": { + "type": "integer", + "default": 300, + "description": "Analysis timeout in seconds" + }, + "severity": { + "type": "array", + "items": {"type": "string", "enum": ["ERROR", "WARNING", "INFO"]}, + "default": ["ERROR", "WARNING", "INFO"], + "description": "Minimum severity levels to report" + }, + "confidence": { + "type": "array", + "items": {"type": "string", "enum": ["HIGH", "MEDIUM", "LOW"]}, + "default": ["HIGH", "MEDIUM", "LOW"], + "description": "Minimum confidence levels to report" + } + } + }, + output_schema={ + "type": "object", + "properties": { + "findings": { + "type": "array", + "description": "Security findings from OpenGrep analysis" + }, + "total_findings": {"type": "integer"}, + "severity_counts": {"type": "object"}, + "files_analyzed": {"type": "integer"}, + } + }, + requires_workspace=True, + ) + + def validate_config(self, config: Dict[str, Any]) -> bool: + """Validate configuration""" + timeout = config.get("timeout", 300) + if not isinstance(timeout, int) or timeout < 30 or timeout > 3600: + raise ValueError("Timeout must be between 30 and 3600 seconds") + + max_bytes = config.get("max_target_bytes", 1000000) + if not isinstance(max_bytes, int) or max_bytes < 1000 or max_bytes > 10000000: + raise ValueError("max_target_bytes must be between 1000 and 10000000") + + custom_rules_path = config.get("custom_rules_path") + if custom_rules_path: + rules_path = Path(custom_rules_path) + if not rules_path.exists(): + logger.warning(f"Custom rules path does not exist: {custom_rules_path}") + + return True + + async def execute(self, config: Dict[str, Any], workspace: Path) -> ModuleResult: + """Execute OpenGrep static analysis on Android code""" + self.start_timer() + + try: + # Validate inputs + self.validate_config(config) + self.validate_workspace(workspace) + + logger.info(f"Running OpenGrep Android analysis on {workspace}") + + # Build opengrep command + cmd = ["opengrep", "scan", "--json"] + + # Add configuration + custom_rules_path = config.get("custom_rules_path") + use_custom_rules = False + if custom_rules_path and Path(custom_rules_path).exists(): + cmd.extend(["--config", custom_rules_path]) + use_custom_rules = True + logger.info(f"Using custom Android rules from: {custom_rules_path}") + else: + config_type = config.get("config", "auto") + if config_type == "auto": + cmd.extend(["--config", "auto"]) + else: + cmd.extend(["--config", config_type]) + + # Add timeout + cmd.extend(["--timeout", str(config.get("timeout", 300))]) + + # Add max target bytes + cmd.extend(["--max-target-bytes", str(config.get("max_target_bytes", 1000000))]) + + # Add languages if specified (but NOT when using custom rules) + languages = config.get("languages", ["java", "kotlin"]) + if languages and not use_custom_rules: + langs = ",".join(languages) + cmd.extend(["--lang", langs]) + logger.debug(f"Analyzing languages: {langs}") + + # Add include patterns + include_patterns = config.get("include_patterns", []) + for pattern in include_patterns: + cmd.extend(["--include", pattern]) + + # Add exclude patterns + exclude_patterns = config.get("exclude_patterns", []) + for pattern in exclude_patterns: + cmd.extend(["--exclude", pattern]) + + # Add severity filter if single level requested + severity_levels = config.get("severity", ["ERROR", "WARNING", "INFO"]) + if severity_levels and len(severity_levels) == 1: + cmd.extend(["--severity", severity_levels[0]]) + + # Disable metrics collection + cmd.append("--disable-version-check") + cmd.append("--no-git-ignore") + + # Add target directory + cmd.append(str(workspace)) + + logger.debug(f"Running command: {' '.join(cmd)}") + + # Run OpenGrep + process = await asyncio.create_subprocess_exec( + *cmd, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE, + cwd=workspace + ) + + stdout, stderr = await process.communicate() + + # Parse results + findings = [] + if process.returncode in [0, 1]: # 0 = no findings, 1 = findings found + findings = self._parse_opengrep_output(stdout.decode(), workspace, config) + logger.info(f"OpenGrep found {len(findings)} potential security issues") + else: + error_msg = stderr.decode() + logger.error(f"OpenGrep failed: {error_msg}") + return self.create_result( + findings=[], + status="failed", + error=f"OpenGrep execution failed (exit code {process.returncode}): {error_msg[:500]}" + ) + + # Create summary + summary = self._create_summary(findings) + + return self.create_result( + findings=findings, + status="success", + summary=summary, + metadata={ + "tool": "opengrep", + "tool_version": "1.45.0", + "languages": languages, + "custom_rules": bool(custom_rules_path), + } + ) + + except Exception as e: + logger.error(f"OpenGrep Android module failed: {e}", exc_info=True) + return self.create_result( + findings=[], + status="failed", + error=str(e) + ) + + def _parse_opengrep_output(self, output: str, workspace: Path, config: Dict[str, Any]) -> List[ModuleFinding]: + """Parse OpenGrep JSON output into findings""" + findings = [] + + if not output.strip(): + return findings + + try: + data = json.loads(output) + results = data.get("results", []) + logger.debug(f"OpenGrep returned {len(results)} raw results") + + # Get filtering criteria + allowed_severities = set(config.get("severity", ["ERROR", "WARNING", "INFO"])) + allowed_confidences = set(config.get("confidence", ["HIGH", "MEDIUM", "LOW"])) + + for result in results: + # Extract basic info + rule_id = result.get("check_id", "unknown") + message = result.get("message", "") + extra = result.get("extra", {}) + severity = extra.get("severity", "INFO").upper() + + # File location info + path_info = result.get("path", "") + start_line = result.get("start", {}).get("line", 0) + end_line = result.get("end", {}).get("line", 0) + + # Code snippet + lines = extra.get("lines", "") + + # Metadata + rule_metadata = extra.get("metadata", {}) + cwe = rule_metadata.get("cwe", []) + owasp = rule_metadata.get("owasp", []) + confidence = extra.get("confidence", rule_metadata.get("confidence", "MEDIUM")).upper() + + # Apply severity filter + if severity not in allowed_severities: + continue + + # Apply confidence filter + if confidence not in allowed_confidences: + continue + + # Make file path relative to workspace + if path_info: + try: + rel_path = Path(path_info).relative_to(workspace) + path_info = str(rel_path) + except ValueError: + pass + + # Map severity to our standard levels + finding_severity = self._map_severity(severity) + + # Create finding + finding = self.create_finding( + title=f"Android Security: {rule_id}", + description=message or f"OpenGrep rule {rule_id} triggered", + severity=finding_severity, + category=self._get_category(rule_id, extra), + file_path=path_info if path_info else None, + line_start=start_line if start_line > 0 else None, + line_end=end_line if end_line > 0 and end_line != start_line else None, + code_snippet=lines.strip() if lines else None, + recommendation=self._get_recommendation(rule_id, extra), + metadata={ + "rule_id": rule_id, + "opengrep_severity": severity, + "confidence": confidence, + "cwe": cwe, + "owasp": owasp, + "fix": extra.get("fix", ""), + "impact": extra.get("impact", ""), + "likelihood": extra.get("likelihood", ""), + "references": extra.get("references", []), + "tool": "opengrep", + } + ) + + findings.append(finding) + + except json.JSONDecodeError as e: + logger.warning(f"Failed to parse OpenGrep output: {e}. Output snippet: {output[:200]}...") + except Exception as e: + logger.warning(f"Error processing OpenGrep results: {e}", exc_info=True) + + return findings + + def _map_severity(self, opengrep_severity: str) -> str: + """Map OpenGrep severity to our standard severity levels""" + severity_map = { + "ERROR": "high", + "WARNING": "medium", + "INFO": "low" + } + return severity_map.get(opengrep_severity.upper(), "medium") + + def _get_category(self, rule_id: str, extra: Dict[str, Any]) -> str: + """Determine finding category based on rule and metadata""" + rule_metadata = extra.get("metadata", {}) + cwe_list = rule_metadata.get("cwe", []) + owasp_list = rule_metadata.get("owasp", []) + + rule_lower = rule_id.lower() + + # Android-specific categories + if "injection" in rule_lower or "sql" in rule_lower: + return "injection" + elif "intent" in rule_lower: + return "android-intent" + elif "webview" in rule_lower: + return "android-webview" + elif "deeplink" in rule_lower: + return "android-deeplink" + elif "storage" in rule_lower or "sharedpreferences" in rule_lower: + return "android-storage" + elif "logging" in rule_lower or "log" in rule_lower: + return "android-logging" + elif "clipboard" in rule_lower: + return "android-clipboard" + elif "activity" in rule_lower or "service" in rule_lower or "provider" in rule_lower: + return "android-component" + elif "crypto" in rule_lower or "encrypt" in rule_lower: + return "cryptography" + elif "hardcode" in rule_lower or "secret" in rule_lower: + return "secrets" + elif "auth" in rule_lower: + return "authentication" + elif cwe_list: + return f"cwe-{cwe_list[0]}" + elif owasp_list: + return f"owasp-{owasp_list[0].replace(' ', '-').lower()}" + else: + return "android-security" + + def _get_recommendation(self, rule_id: str, extra: Dict[str, Any]) -> str: + """Generate recommendation based on rule and metadata""" + fix_suggestion = extra.get("fix", "") + if fix_suggestion: + return fix_suggestion + + rule_lower = rule_id.lower() + + # Android-specific recommendations + if "injection" in rule_lower or "sql" in rule_lower: + return "Use parameterized queries or Room database with type-safe queries to prevent SQL injection." + elif "intent" in rule_lower: + return "Validate all incoming Intent data and use explicit Intents when possible to prevent Intent manipulation attacks." + elif "webview" in rule_lower and "javascript" in rule_lower: + return "Disable JavaScript in WebView if not needed, or implement proper JavaScript interfaces with @JavascriptInterface annotation." + elif "deeplink" in rule_lower: + return "Validate all deeplink URLs and sanitize user input to prevent deeplink hijacking attacks." + elif "storage" in rule_lower or "sharedpreferences" in rule_lower: + return "Encrypt sensitive data before storing in SharedPreferences or use EncryptedSharedPreferences for Android API 23+." + elif "logging" in rule_lower: + return "Remove sensitive data from logs in production builds. Use ProGuard/R8 to strip logging statements." + elif "clipboard" in rule_lower: + return "Avoid placing sensitive data on the clipboard. If necessary, clear clipboard data when no longer needed." + elif "crypto" in rule_lower: + return "Use modern cryptographic algorithms (AES-GCM, RSA-OAEP) and Android Keystore for key management." + elif "hardcode" in rule_lower or "secret" in rule_lower: + return "Remove hardcoded secrets. Use Android Keystore, environment variables, or secure configuration management." + else: + return "Review this Android security issue and apply appropriate fixes based on Android security best practices." + + def _create_summary(self, findings: List[ModuleFinding]) -> Dict[str, Any]: + """Create analysis summary""" + severity_counts = {"critical": 0, "high": 0, "medium": 0, "low": 0} + category_counts = {} + rule_counts = {} + + for finding in findings: + # Count by severity + severity_counts[finding.severity] += 1 + + # Count by category + category = finding.category + category_counts[category] = category_counts.get(category, 0) + 1 + + # Count by rule + rule_id = finding.metadata.get("rule_id", "unknown") + rule_counts[rule_id] = rule_counts.get(rule_id, 0) + 1 + + return { + "total_findings": len(findings), + "severity_counts": severity_counts, + "category_counts": category_counts, + "top_rules": dict(sorted(rule_counts.items(), key=lambda x: x[1], reverse=True)[:10]), + "files_analyzed": len(set(f.file_path for f in findings if f.file_path)) + } diff --git a/backend/toolbox/modules/scanner/__init__.py b/backend/toolbox/modules/scanner/__init__.py index ae02119..3efefe6 100644 --- a/backend/toolbox/modules/scanner/__init__.py +++ b/backend/toolbox/modules/scanner/__init__.py @@ -10,5 +10,6 @@ # Additional attribution and requirements are provided in the NOTICE file. from .file_scanner import FileScanner +from .dependency_scanner import DependencyScanner -__all__ = ["FileScanner"] \ No newline at end of file +__all__ = ["FileScanner", "DependencyScanner"] \ No newline at end of file diff --git a/backend/toolbox/modules/scanner/dependency_scanner.py b/backend/toolbox/modules/scanner/dependency_scanner.py new file mode 100644 index 0000000..4c7791c --- /dev/null +++ b/backend/toolbox/modules/scanner/dependency_scanner.py @@ -0,0 +1,302 @@ +""" +Dependency Scanner Module - Scans Python dependencies for known vulnerabilities using pip-audit +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +import asyncio +import json +import logging +import time +from pathlib import Path +from typing import Dict, Any, List + +try: + from toolbox.modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding +except ImportError: + try: + from modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding + except ImportError: + from src.toolbox.modules.base import BaseModule, ModuleMetadata, ModuleResult, ModuleFinding + +logger = logging.getLogger(__name__) + + +class DependencyScanner(BaseModule): + """ + Scans Python dependencies for known vulnerabilities using pip-audit. + + This module: + - Discovers dependency files (requirements.txt, pyproject.toml, setup.py, Pipfile) + - Runs pip-audit to check for vulnerable dependencies + - Reports CVEs with severity and affected versions + """ + + def get_metadata(self) -> ModuleMetadata: + """Get module metadata""" + return ModuleMetadata( + name="dependency_scanner", + version="1.0.0", + description="Scans Python dependencies for known vulnerabilities", + author="FuzzForge Team", + category="scanner", + tags=["dependencies", "cve", "vulnerabilities", "pip-audit"], + input_schema={ + "dependency_files": { + "type": "array", + "items": {"type": "string"}, + "description": "List of dependency files to scan (auto-discovered if empty)", + "default": [] + }, + "ignore_vulns": { + "type": "array", + "items": {"type": "string"}, + "description": "List of vulnerability IDs to ignore", + "default": [] + } + }, + output_schema={ + "findings": { + "type": "array", + "description": "List of vulnerable dependencies with CVE information" + } + }, + requires_workspace=True + ) + + def validate_config(self, config: Dict[str, Any]) -> bool: + """Validate module configuration""" + dep_files = config.get("dependency_files", []) + if not isinstance(dep_files, list): + raise ValueError("dependency_files must be a list") + + ignore_vulns = config.get("ignore_vulns", []) + if not isinstance(ignore_vulns, list): + raise ValueError("ignore_vulns must be a list") + + return True + + def _discover_dependency_files(self, workspace: Path) -> List[Path]: + """ + Discover Python dependency files in workspace. + + Returns: + List of discovered dependency file paths + """ + dependency_patterns = [ + "requirements.txt", + "*requirements*.txt", + "pyproject.toml", + "setup.py", + "Pipfile", + "poetry.lock" + ] + + found_files = [] + for pattern in dependency_patterns: + found_files.extend(workspace.rglob(pattern)) + + # Deduplicate and return + unique_files = list(set(found_files)) + logger.info(f"Discovered {len(unique_files)} dependency files") + return unique_files + + async def _run_pip_audit(self, file_path: Path) -> Dict[str, Any]: + """ + Run pip-audit on a specific dependency file. + + Args: + file_path: Path to dependency file + + Returns: + pip-audit JSON output as dict + """ + try: + # Run pip-audit with JSON output + cmd = [ + "pip-audit", + "--requirement", str(file_path), + "--format", "json", + "--progress-spinner", "off" + ] + + logger.info(f"Running pip-audit on: {file_path.name}") + process = await asyncio.create_subprocess_exec( + *cmd, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE + ) + + stdout, stderr = await process.communicate() + + # pip-audit returns 0 if no vulns, 1 if vulns found + if process.returncode not in [0, 1]: + logger.error(f"pip-audit failed: {stderr.decode()}") + return {"dependencies": []} + + # Parse JSON output + result = json.loads(stdout.decode()) + return result + + except Exception as e: + logger.error(f"Error running pip-audit on {file_path}: {e}") + return {"dependencies": []} + + def _convert_to_findings( + self, + audit_result: Dict[str, Any], + file_path: Path, + workspace: Path, + ignore_vulns: List[str] + ) -> List[ModuleFinding]: + """ + Convert pip-audit results to ModuleFindings. + + Args: + audit_result: pip-audit JSON output + file_path: Path to scanned file + workspace: Workspace path for relative path calculation + ignore_vulns: List of vulnerability IDs to ignore + + Returns: + List of ModuleFindings + """ + findings = [] + + # pip-audit format: {"dependencies": [{package, version, vulns: []}]} + for dep in audit_result.get("dependencies", []): + package_name = dep.get("name", "unknown") + package_version = dep.get("version", "unknown") + vulnerabilities = dep.get("vulns", []) + + for vuln in vulnerabilities: + vuln_id = vuln.get("id", "UNKNOWN") + + # Skip if in ignore list + if vuln_id in ignore_vulns: + logger.debug(f"Ignoring vulnerability: {vuln_id}") + continue + + description = vuln.get("description", "No description available") + fix_versions = vuln.get("fix_versions", []) + + # Map CVSS scores to severity + # pip-audit doesn't always provide CVSS, so we default to medium + severity = "medium" + + # Try to get relative path + try: + rel_path = file_path.relative_to(workspace) + except ValueError: + rel_path = file_path + + recommendation = f"Upgrade {package_name} to a fixed version: {', '.join(fix_versions)}" if fix_versions else f"Check for updates to {package_name}" + + finding = self.create_finding( + title=f"Vulnerable dependency: {package_name} ({vuln_id})", + description=f"{description}\n\nAffected package: {package_name} {package_version}", + severity=severity, + category="vulnerable-dependency", + file_path=str(rel_path), + recommendation=recommendation, + metadata={ + "cve_id": vuln_id, + "package": package_name, + "installed_version": package_version, + "fix_versions": fix_versions, + "aliases": vuln.get("aliases", []), + "link": vuln.get("link", "") + } + ) + findings.append(finding) + + return findings + + async def execute(self, config: Dict[str, Any], workspace: Path) -> ModuleResult: + """ + Execute the dependency scanning module. + + Args: + config: Module configuration + workspace: Path to workspace + + Returns: + ModuleResult with vulnerability findings + """ + start_time = time.time() + metadata = self.get_metadata() + + # Validate inputs + self.validate_config(config) + self.validate_workspace(workspace) + + # Get configuration + specified_files = config.get("dependency_files", []) + ignore_vulns = config.get("ignore_vulns", []) + + # Discover or use specified dependency files + if specified_files: + dep_files = [workspace / f for f in specified_files] + else: + dep_files = self._discover_dependency_files(workspace) + + if not dep_files: + logger.warning("No dependency files found in workspace") + return ModuleResult( + module=metadata.name, + version=metadata.version, + status="success", + execution_time=time.time() - start_time, + findings=[], + summary={ + "total_files": 0, + "total_vulnerabilities": 0, + "vulnerable_packages": 0 + } + ) + + # Scan each dependency file + all_findings = [] + files_scanned = 0 + + for dep_file in dep_files: + if not dep_file.exists(): + logger.warning(f"Dependency file not found: {dep_file}") + continue + + logger.info(f"Scanning dependencies in: {dep_file.name}") + audit_result = await self._run_pip_audit(dep_file) + findings = self._convert_to_findings(audit_result, dep_file, workspace, ignore_vulns) + + all_findings.extend(findings) + files_scanned += 1 + + # Calculate summary + unique_packages = len(set(f.metadata.get("package") for f in all_findings)) + + execution_time = time.time() - start_time + + return ModuleResult( + module=metadata.name, + version=metadata.version, + status="success", + execution_time=execution_time, + findings=all_findings, + summary={ + "total_files": files_scanned, + "total_vulnerabilities": len(all_findings), + "vulnerable_packages": unique_packages + }, + metadata={ + "scanned_files": [str(f.name) for f in dep_files if f.exists()] + } + ) diff --git a/backend/toolbox/modules/secret_detection/llm_secret_detector.py b/backend/toolbox/modules/secret_detection/llm_secret_detector.py index 3ba96f8..1adf341 100644 --- a/backend/toolbox/modules/secret_detection/llm_secret_detector.py +++ b/backend/toolbox/modules/secret_detection/llm_secret_detector.py @@ -107,7 +107,8 @@ class LLMSecretDetectorModule(BaseModule): ) agent_url = config.get("agent_url") - if not agent_url or not isinstance(agent_url, str): + # agent_url is optional - will have default from metadata.yaml + if agent_url is not None and not isinstance(agent_url, str): raise ValueError("agent_url must be a valid URL string") max_files = config.get("max_files", 20) @@ -131,14 +132,14 @@ class LLMSecretDetectorModule(BaseModule): logger.info(f"Starting LLM secret detection in workspace: {workspace}") - # Extract configuration - agent_url = config.get("agent_url", "http://fuzzforge-task-agent:8000/a2a/litellm_agent") - llm_model = config.get("llm_model", "gpt-4o-mini") - llm_provider = config.get("llm_provider", "openai") - file_patterns = config.get("file_patterns", ["*.py", "*.js", "*.ts", "*.java", "*.go", "*.env", "*.yaml", "*.yml", "*.json", "*.xml", "*.ini", "*.sql", "*.properties", "*.sh", "*.bat", "*.config", "*.conf", "*.toml", "*id_rsa*", "*.txt"]) - max_files = config.get("max_files", 20) - max_file_size = config.get("max_file_size", 30000) - timeout = config.get("timeout", 30) # Reduced from 45s + # Extract configuration (defaults come from metadata.yaml via API) + agent_url = config["agent_url"] + llm_model = config["llm_model"] + llm_provider = config["llm_provider"] + file_patterns = config["file_patterns"] + max_files = config["max_files"] + max_file_size = config["max_file_size"] + timeout = config["timeout"] # Find files to analyze # Skip files that are unlikely to contain secrets diff --git a/backend/toolbox/workflows/android_static_analysis/__init__.py b/backend/toolbox/workflows/android_static_analysis/__init__.py new file mode 100644 index 0000000..aec13c5 --- /dev/null +++ b/backend/toolbox/workflows/android_static_analysis/__init__.py @@ -0,0 +1,35 @@ +""" +Android Static Analysis Workflow + +Comprehensive Android application security testing combining: +- Jadx APK decompilation +- OpenGrep/Semgrep static analysis with Android-specific rules +- MobSF mobile security framework analysis +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +from .workflow import AndroidStaticAnalysisWorkflow +from .activities import ( + decompile_with_jadx_activity, + scan_with_opengrep_activity, + scan_with_mobsf_activity, + generate_android_sarif_activity, +) + +__all__ = [ + "AndroidStaticAnalysisWorkflow", + "decompile_with_jadx_activity", + "scan_with_opengrep_activity", + "scan_with_mobsf_activity", + "generate_android_sarif_activity", +] diff --git a/backend/toolbox/workflows/android_static_analysis/activities.py b/backend/toolbox/workflows/android_static_analysis/activities.py new file mode 100644 index 0000000..5d37729 --- /dev/null +++ b/backend/toolbox/workflows/android_static_analysis/activities.py @@ -0,0 +1,213 @@ +""" +Android Static Analysis Workflow Activities + +Activities for the Android security testing workflow: +- decompile_with_jadx_activity: Decompile APK using Jadx +- scan_with_opengrep_activity: Analyze code with OpenGrep/Semgrep +- scan_with_mobsf_activity: Scan APK with MobSF +- generate_android_sarif_activity: Generate combined SARIF report +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +import logging +import sys +from pathlib import Path + +from temporalio import activity + +# Configure logging +logger = logging.getLogger(__name__) + +# Add toolbox to path for module imports +sys.path.insert(0, '/app/toolbox') + + +@activity.defn(name="decompile_with_jadx") +async def decompile_with_jadx_activity(workspace_path: str, config: dict) -> dict: + """ + Decompile Android APK to Java source code using Jadx. + + Args: + workspace_path: Path to the workspace directory + config: JadxDecompiler configuration + + Returns: + Decompilation results dictionary + """ + logger.info(f"Activity: decompile_with_jadx (workspace={workspace_path})") + + try: + from modules.android import JadxDecompiler + + workspace = Path(workspace_path) + if not workspace.exists(): + raise FileNotFoundError(f"Workspace not found: {workspace_path}") + + decompiler = JadxDecompiler() + result = await decompiler.execute(config, workspace) + + logger.info( + f"✓ Jadx decompilation completed: " + f"{result.summary.get('java_files', 0)} Java files generated" + ) + return result.dict() + + except Exception as e: + logger.error(f"Jadx decompilation failed: {e}", exc_info=True) + raise + + +@activity.defn(name="scan_with_opengrep") +async def scan_with_opengrep_activity(workspace_path: str, config: dict) -> dict: + """ + Analyze Android code for security issues using OpenGrep/Semgrep. + + Args: + workspace_path: Path to the workspace directory + config: OpenGrepAndroid configuration + + Returns: + Analysis results dictionary + """ + logger.info(f"Activity: scan_with_opengrep (workspace={workspace_path})") + + try: + from modules.android import OpenGrepAndroid + + workspace = Path(workspace_path) + if not workspace.exists(): + raise FileNotFoundError(f"Workspace not found: {workspace_path}") + + analyzer = OpenGrepAndroid() + result = await analyzer.execute(config, workspace) + + logger.info( + f"✓ OpenGrep analysis completed: " + f"{result.summary.get('total_findings', 0)} security issues found" + ) + return result.dict() + + except Exception as e: + logger.error(f"OpenGrep analysis failed: {e}", exc_info=True) + raise + + +@activity.defn(name="scan_with_mobsf") +async def scan_with_mobsf_activity(workspace_path: str, config: dict) -> dict: + """ + Analyze Android APK for security issues using MobSF. + + Args: + workspace_path: Path to the workspace directory + config: MobSFScanner configuration + + Returns: + Scan results dictionary (or skipped status if MobSF unavailable) + """ + logger.info(f"Activity: scan_with_mobsf (workspace={workspace_path})") + + # Check if MobSF is installed (graceful degradation for ARM64 platform) + mobsf_path = Path("/app/mobsf") + if not mobsf_path.exists(): + logger.warning("MobSF not installed on this platform (ARM64/Rosetta limitation)") + return { + "status": "skipped", + "findings": [], + "summary": { + "total_findings": 0, + "skip_reason": "MobSF unavailable on ARM64 platform (Rosetta 2 incompatibility)" + } + } + + try: + from modules.android import MobSFScanner + + workspace = Path(workspace_path) + if not workspace.exists(): + raise FileNotFoundError(f"Workspace not found: {workspace_path}") + + scanner = MobSFScanner() + result = await scanner.execute(config, workspace) + + logger.info( + f"✓ MobSF scan completed: " + f"{result.summary.get('total_findings', 0)} findings" + ) + return result.dict() + + except Exception as e: + logger.error(f"MobSF scan failed: {e}", exc_info=True) + raise + + +@activity.defn(name="generate_android_sarif") +async def generate_android_sarif_activity( + jadx_result: dict, + opengrep_result: dict, + mobsf_result: dict, + config: dict, + workspace_path: str +) -> dict: + """ + Generate combined SARIF report from all Android security findings. + + Args: + jadx_result: Jadx decompilation results + opengrep_result: OpenGrep analysis results + mobsf_result: MobSF scan results (may be None if disabled) + config: Reporter configuration + workspace_path: Workspace path + + Returns: + SARIF report dictionary + """ + logger.info("Activity: generate_android_sarif") + + try: + from modules.reporter import SARIFReporter + + workspace = Path(workspace_path) + + # Collect all findings + all_findings = [] + all_findings.extend(opengrep_result.get("findings", [])) + + if mobsf_result: + all_findings.extend(mobsf_result.get("findings", [])) + + # Prepare reporter config + reporter_config = { + **(config or {}), + "findings": all_findings, + "tool_name": "FuzzForge Android Static Analysis", + "tool_version": "1.0.0", + "metadata": { + "jadx_version": "1.5.0", + "opengrep_version": "1.45.0", + "mobsf_version": "3.9.7", + "java_files_decompiled": jadx_result.get("summary", {}).get("java_files", 0), + } + } + + reporter = SARIFReporter() + result = await reporter.execute(reporter_config, workspace) + + sarif_report = result.dict().get("sarif", {}) + + logger.info(f"✓ SARIF report generated with {len(all_findings)} findings") + + return sarif_report + + except Exception as e: + logger.error(f"SARIF report generation failed: {e}", exc_info=True) + raise diff --git a/backend/toolbox/workflows/android_static_analysis/metadata.yaml b/backend/toolbox/workflows/android_static_analysis/metadata.yaml new file mode 100644 index 0000000..cd77e48 --- /dev/null +++ b/backend/toolbox/workflows/android_static_analysis/metadata.yaml @@ -0,0 +1,172 @@ +name: android_static_analysis +version: "1.0.0" +vertical: android +description: "Comprehensive Android application security testing using Jadx decompilation, OpenGrep static analysis, and MobSF mobile security framework" +author: "FuzzForge Team" +tags: + - "android" + - "mobile" + - "static-analysis" + - "security" + - "opengrep" + - "semgrep" + - "mobsf" + - "jadx" + - "apk" + - "sarif" + +# Workspace isolation mode +# Using "shared" mode for read-only APK analysis (no file modifications except decompilation output) +workspace_isolation: "shared" + +parameters: + type: object + properties: + apk_path: + type: string + description: "Path to the APK file to analyze (relative to uploaded target or absolute within workspace)" + default: "" + + decompile_apk: + type: boolean + description: "Whether to decompile APK with Jadx before OpenGrep analysis" + default: true + + jadx_config: + type: object + description: "Jadx decompiler configuration" + properties: + output_dir: + type: string + description: "Output directory for decompiled sources" + default: "jadx_output" + overwrite: + type: boolean + description: "Overwrite existing decompilation output" + default: true + threads: + type: integer + description: "Number of decompilation threads" + default: 4 + minimum: 1 + maximum: 32 + decompiler_args: + type: array + items: + type: string + description: "Additional Jadx arguments" + default: [] + + opengrep_config: + type: object + description: "OpenGrep/Semgrep static analysis configuration" + properties: + config: + type: string + enum: ["auto", "p/security-audit", "p/owasp-top-ten", "p/cwe-top-25"] + description: "Preset OpenGrep ruleset (ignored if custom_rules_path is set)" + default: "auto" + custom_rules_path: + type: string + description: "Path to custom OpenGrep rules directory (use Android-specific rules for best results)" + default: "/app/toolbox/modules/android/custom_rules" + languages: + type: array + items: + type: string + description: "Programming languages to analyze (defaults to java, kotlin for Android)" + default: ["java", "kotlin"] + include_patterns: + type: array + items: + type: string + description: "File patterns to include in scan" + default: [] + exclude_patterns: + type: array + items: + type: string + description: "File patterns to exclude from scan" + default: [] + max_target_bytes: + type: integer + description: "Maximum file size to analyze (bytes)" + default: 1000000 + timeout: + type: integer + description: "Analysis timeout in seconds" + default: 300 + severity: + type: array + items: + type: string + enum: ["ERROR", "WARNING", "INFO"] + description: "Severity levels to include in results" + default: ["ERROR", "WARNING", "INFO"] + confidence: + type: array + items: + type: string + enum: ["HIGH", "MEDIUM", "LOW"] + description: "Confidence levels to include in results" + default: ["HIGH", "MEDIUM", "LOW"] + + mobsf_config: + type: object + description: "MobSF scanner configuration" + properties: + enabled: + type: boolean + description: "Enable MobSF analysis (requires APK file)" + default: true + mobsf_url: + type: string + description: "MobSF server URL" + default: "http://localhost:8877" + api_key: + type: string + description: "MobSF API key (if not provided, uses MOBSF_API_KEY env var)" + default: null + rescan: + type: boolean + description: "Force rescan even if APK was previously analyzed" + default: false + + reporter_config: + type: object + description: "SARIF reporter configuration" + properties: + include_code_flows: + type: boolean + description: "Include code flow information in SARIF output" + default: false + logical_id: + type: string + description: "Custom identifier for the SARIF report" + default: null + +output_schema: + type: object + properties: + sarif: + type: object + description: "SARIF-formatted findings from all Android security tools" + summary: + type: object + description: "Android security analysis summary" + properties: + total_findings: + type: integer + decompiled_java_files: + type: integer + description: "Number of Java files decompiled by Jadx" + opengrep_findings: + type: integer + description: "Findings from OpenGrep/Semgrep analysis" + mobsf_findings: + type: integer + description: "Findings from MobSF analysis" + severity_distribution: + type: object + category_distribution: + type: object diff --git a/backend/toolbox/workflows/android_static_analysis/workflow.py b/backend/toolbox/workflows/android_static_analysis/workflow.py new file mode 100644 index 0000000..8376cd2 --- /dev/null +++ b/backend/toolbox/workflows/android_static_analysis/workflow.py @@ -0,0 +1,289 @@ +""" +Android Static Analysis Workflow - Temporal Version + +Comprehensive security testing for Android applications using Jadx, OpenGrep, and MobSF. +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +from datetime import timedelta +from typing import Dict, Any, Optional +from pathlib import Path + +from temporalio import workflow +from temporalio.common import RetryPolicy + +# Import activity interfaces (will be executed by worker) +with workflow.unsafe.imports_passed_through(): + import logging + +logger = logging.getLogger(__name__) + + +@workflow.defn +class AndroidStaticAnalysisWorkflow: + """ + Android Static Application Security Testing workflow. + + This workflow: + 1. Downloads target (APK) from MinIO + 2. (Optional) Decompiles APK using Jadx + 3. Runs OpenGrep/Semgrep static analysis on decompiled code + 4. (Optional) Runs MobSF comprehensive security scan + 5. Generates a SARIF report with all findings + 6. Uploads results to MinIO + 7. Cleans up cache + """ + + @workflow.run + async def run( + self, + target_id: str, + apk_path: Optional[str] = None, + decompile_apk: bool = True, + jadx_config: Optional[Dict[str, Any]] = None, + opengrep_config: Optional[Dict[str, Any]] = None, + mobsf_config: Optional[Dict[str, Any]] = None, + reporter_config: Optional[Dict[str, Any]] = None + ) -> Dict[str, Any]: + """ + Main workflow execution. + + Args: + target_id: UUID of the uploaded target (APK) in MinIO + apk_path: Path to APK file within target (if target is not a single APK) + decompile_apk: Whether to decompile APK with Jadx before OpenGrep + jadx_config: Configuration for Jadx decompiler + opengrep_config: Configuration for OpenGrep analyzer + mobsf_config: Configuration for MobSF scanner + reporter_config: Configuration for SARIF reporter + + Returns: + Dictionary containing SARIF report and summary + """ + workflow_id = workflow.info().workflow_id + + workflow.logger.info( + f"Starting AndroidStaticAnalysisWorkflow " + f"(workflow_id={workflow_id}, target_id={target_id})" + ) + + # Default configurations + if not jadx_config: + jadx_config = { + "output_dir": "jadx_output", + "overwrite": True, + "threads": 4, + "decompiler_args": [] + } + + if not opengrep_config: + opengrep_config = { + "config": "auto", + "custom_rules_path": "/app/toolbox/modules/android/custom_rules", + "languages": ["java", "kotlin"], + "severity": ["ERROR", "WARNING", "INFO"], + "confidence": ["HIGH", "MEDIUM", "LOW"], + "timeout": 300, + } + + if not mobsf_config: + mobsf_config = { + "enabled": True, + "mobsf_url": "http://localhost:8877", + "api_key": None, + "rescan": False, + } + + if not reporter_config: + reporter_config = { + "include_code_flows": False + } + + # Activity retry policy + retry_policy = RetryPolicy( + initial_interval=timedelta(seconds=1), + maximum_interval=timedelta(seconds=60), + maximum_attempts=3, + backoff_coefficient=2.0, + ) + + # Phase 0: Download target from MinIO + workflow.logger.info(f"Phase 0: Downloading target from MinIO (target_id={target_id})") + workspace_path = await workflow.execute_activity( + "get_target", + args=[target_id, workflow.info().workflow_id, "shared"], + start_to_close_timeout=timedelta(minutes=10), + retry_policy=retry_policy, + ) + workflow.logger.info(f"✓ Target downloaded to: {workspace_path}") + + # Handle case where workspace_path is a file (single APK upload) + # vs. a directory containing files + workspace_path_obj = Path(workspace_path) + + # Determine actual workspace directory and APK path + if apk_path: + # User explicitly provided apk_path + actual_apk_path = apk_path + # workspace_path could be either a file or directory + # If it's a file and apk_path matches the filename, use parent as workspace + if workspace_path_obj.name == apk_path: + workspace_path = str(workspace_path_obj.parent) + workflow.logger.info(f"Adjusted workspace to parent directory: {workspace_path}") + else: + # No apk_path provided - check if workspace_path is an APK file + if workspace_path_obj.suffix.lower() == '.apk' or workspace_path_obj.name.endswith('.apk'): + # workspace_path is the APK file itself + actual_apk_path = workspace_path_obj.name + workspace_path = str(workspace_path_obj.parent) + workflow.logger.info(f"Detected single APK file: {actual_apk_path}, workspace: {workspace_path}") + else: + # workspace_path is a directory, need to find APK within it + actual_apk_path = None + workflow.logger.info("Workspace is a directory, APK detection will be handled by modules") + + # Phase 1: Jadx decompilation (if enabled and APK provided) + jadx_result = None + analysis_workspace = workspace_path + + if decompile_apk and actual_apk_path: + workflow.logger.info(f"Phase 1: Decompiling APK with Jadx (apk={actual_apk_path})") + + jadx_activity_config = { + **jadx_config, + "apk_path": actual_apk_path + } + + jadx_result = await workflow.execute_activity( + "decompile_with_jadx", + args=[workspace_path, jadx_activity_config], + start_to_close_timeout=timedelta(minutes=15), + retry_policy=retry_policy, + ) + + if jadx_result.get("status") == "success": + # Use decompiled sources as workspace for OpenGrep + source_dir = jadx_result.get("summary", {}).get("source_dir") + if source_dir: + analysis_workspace = source_dir + workflow.logger.info( + f"✓ Jadx decompiled {jadx_result.get('summary', {}).get('java_files', 0)} Java files" + ) + else: + workflow.logger.warning(f"Jadx decompilation failed: {jadx_result.get('error')}") + else: + workflow.logger.info("Phase 1: Jadx decompilation skipped") + + # Phase 2: OpenGrep static analysis + workflow.logger.info(f"Phase 2: OpenGrep analysis on {analysis_workspace}") + + opengrep_result = await workflow.execute_activity( + "scan_with_opengrep", + args=[analysis_workspace, opengrep_config], + start_to_close_timeout=timedelta(minutes=20), + retry_policy=retry_policy, + ) + + workflow.logger.info( + f"✓ OpenGrep completed: {opengrep_result.get('summary', {}).get('total_findings', 0)} findings" + ) + + # Phase 3: MobSF analysis (if enabled and APK provided) + mobsf_result = None + + if mobsf_config.get("enabled", True) and actual_apk_path: + workflow.logger.info(f"Phase 3: MobSF scan on APK: {actual_apk_path}") + + mobsf_activity_config = { + **mobsf_config, + "file_path": actual_apk_path + } + + try: + mobsf_result = await workflow.execute_activity( + "scan_with_mobsf", + args=[workspace_path, mobsf_activity_config], + start_to_close_timeout=timedelta(minutes=30), + retry_policy=RetryPolicy( + maximum_attempts=2 # MobSF can be flaky, limit retries + ), + ) + + # Handle skipped or completed status + if mobsf_result.get("status") == "skipped": + workflow.logger.warning( + f"⚠️ MobSF skipped: {mobsf_result.get('summary', {}).get('skip_reason', 'Unknown reason')}" + ) + else: + workflow.logger.info( + f"✓ MobSF completed: {mobsf_result.get('summary', {}).get('total_findings', 0)} findings" + ) + except Exception as e: + workflow.logger.warning(f"MobSF scan failed (continuing without it): {e}") + mobsf_result = None + else: + workflow.logger.info("Phase 3: MobSF scan skipped (disabled or no APK)") + + # Phase 4: Generate SARIF report + workflow.logger.info("Phase 4: Generating SARIF report") + + sarif_report = await workflow.execute_activity( + "generate_android_sarif", + args=[jadx_result or {}, opengrep_result, mobsf_result, reporter_config, workspace_path], + start_to_close_timeout=timedelta(minutes=5), + retry_policy=retry_policy, + ) + + # Phase 5: Upload results to MinIO + workflow.logger.info("Phase 5: Uploading results to MinIO") + + result_url = await workflow.execute_activity( + "upload_results", + args=[workflow.info().workflow_id, sarif_report, "sarif"], + start_to_close_timeout=timedelta(minutes=10), + retry_policy=retry_policy, + ) + + workflow.logger.info(f"✓ Results uploaded: {result_url}") + + # Phase 6: Cleanup cache + workflow.logger.info("Phase 6: Cleaning up cache") + + await workflow.execute_activity( + "cleanup_cache", + args=[workspace_path, "shared"], + start_to_close_timeout=timedelta(minutes=5), + retry_policy=RetryPolicy(maximum_attempts=1), # Don't retry cleanup + ) + + # Calculate summary + total_findings = len(sarif_report.get("runs", [{}])[0].get("results", [])) + + summary = { + "workflow": "android_static_analysis", + "target_id": target_id, + "total_findings": total_findings, + "decompiled_java_files": (jadx_result or {}).get("summary", {}).get("java_files", 0) if jadx_result else 0, + "opengrep_findings": opengrep_result.get("summary", {}).get("total_findings", 0), + "mobsf_findings": mobsf_result.get("summary", {}).get("total_findings", 0) if mobsf_result else 0, + "result_url": result_url, + } + + workflow.logger.info( + f"✅ AndroidStaticAnalysisWorkflow completed successfully: {total_findings} findings" + ) + + return { + "sarif": sarif_report, + "summary": summary, + } diff --git a/backend/toolbox/workflows/atheris_fuzzing/metadata.yaml b/backend/toolbox/workflows/atheris_fuzzing/metadata.yaml index b079804..c119aad 100644 --- a/backend/toolbox/workflows/atheris_fuzzing/metadata.yaml +++ b/backend/toolbox/workflows/atheris_fuzzing/metadata.yaml @@ -16,11 +16,6 @@ tags: # - "copy-on-write": Download once, copy for each run (balances performance and isolation) workspace_isolation: "isolated" -default_parameters: - target_file: null - max_iterations: 1000000 - timeout_seconds: 1800 - parameters: type: object properties: diff --git a/backend/toolbox/workflows/cargo_fuzzing/metadata.yaml b/backend/toolbox/workflows/cargo_fuzzing/metadata.yaml index 39ff622..829a1f3 100644 --- a/backend/toolbox/workflows/cargo_fuzzing/metadata.yaml +++ b/backend/toolbox/workflows/cargo_fuzzing/metadata.yaml @@ -16,12 +16,6 @@ tags: # - "copy-on-write": Download once, copy for each run (balances performance and isolation) workspace_isolation: "isolated" -default_parameters: - target_name: null - max_iterations: 1000000 - timeout_seconds: 1800 - sanitizer: "address" - parameters: type: object properties: diff --git a/backend/toolbox/workflows/gitleaks_detection/metadata.yaml b/backend/toolbox/workflows/gitleaks_detection/metadata.yaml index d2c343c..ad4ae45 100644 --- a/backend/toolbox/workflows/gitleaks_detection/metadata.yaml +++ b/backend/toolbox/workflows/gitleaks_detection/metadata.yaml @@ -30,13 +30,5 @@ parameters: default: false description: "Scan files without Git context" -default_parameters: - scan_mode: "detect" - redact: true - no_git: false - required_modules: - "gitleaks" - -supported_volume_modes: - - "ro" diff --git a/backend/toolbox/workflows/llm_analysis/metadata.yaml b/backend/toolbox/workflows/llm_analysis/metadata.yaml index 0a388bf..2631b59 100644 --- a/backend/toolbox/workflows/llm_analysis/metadata.yaml +++ b/backend/toolbox/workflows/llm_analysis/metadata.yaml @@ -13,38 +13,84 @@ tags: # Workspace isolation mode workspace_isolation: "shared" -default_parameters: - agent_url: "http://fuzzforge-task-agent:8000/a2a/litellm_agent" - llm_model: "gpt-5-mini" - llm_provider: "openai" - max_files: 5 - parameters: type: object properties: agent_url: type: string description: "A2A agent endpoint URL" + default: "http://fuzzforge-task-agent:8000/a2a/litellm_agent" llm_model: type: string description: "LLM model to use (e.g., gpt-4o-mini, claude-3-5-sonnet)" + default: "gpt-5-mini" llm_provider: type: string description: "LLM provider (openai, anthropic, etc.)" + default: "openai" file_patterns: type: array items: type: string - description: "File patterns to analyze (e.g., ['*.py', '*.js'])" + default: + - "*.py" + - "*.js" + - "*.ts" + - "*.jsx" + - "*.tsx" + - "*.java" + - "*.go" + - "*.rs" + - "*.c" + - "*.cpp" + - "*.h" + - "*.hpp" + - "*.cs" + - "*.php" + - "*.rb" + - "*.swift" + - "*.kt" + - "*.scala" + - "*.env" + - "*.yaml" + - "*.yml" + - "*.json" + - "*.xml" + - "*.ini" + - "*.sql" + - "*.properties" + - "*.sh" + - "*.bat" + - "*.ps1" + - "*.config" + - "*.conf" + - "*.toml" + - "*id_rsa*" + - "*id_dsa*" + - "*id_ecdsa*" + - "*id_ed25519*" + - "*.pem" + - "*.key" + - "*.pub" + - "*.txt" + - "*.md" + - "Dockerfile" + - "docker-compose.yml" + - ".gitignore" + - ".dockerignore" + description: "File patterns to analyze for security issues and secrets" max_files: type: integer description: "Maximum number of files to analyze" + default: 10 max_file_size: type: integer description: "Maximum file size in bytes" + default: 100000 timeout: type: integer description: "Timeout per file in seconds" + default: 90 output_schema: type: object diff --git a/backend/toolbox/workflows/llm_secret_detection/metadata.yaml b/backend/toolbox/workflows/llm_secret_detection/metadata.yaml index cf761ef..a97b859 100644 --- a/backend/toolbox/workflows/llm_secret_detection/metadata.yaml +++ b/backend/toolbox/workflows/llm_secret_detection/metadata.yaml @@ -30,14 +30,42 @@ parameters: type: integer default: 20 -default_parameters: - agent_url: "http://fuzzforge-task-agent:8000/a2a/litellm_agent" - llm_model: "gpt-5-mini" - llm_provider: "openai" - max_files: 20 + max_file_size: + type: integer + default: 30000 + description: "Maximum file size in bytes" + + timeout: + type: integer + default: 30 + description: "Timeout per file in seconds" + + file_patterns: + type: array + items: + type: string + default: + - "*.py" + - "*.js" + - "*.ts" + - "*.java" + - "*.go" + - "*.env" + - "*.yaml" + - "*.yml" + - "*.json" + - "*.xml" + - "*.ini" + - "*.sql" + - "*.properties" + - "*.sh" + - "*.bat" + - "*.config" + - "*.conf" + - "*.toml" + - "*id_rsa*" + - "*.txt" + description: "File patterns to scan for secrets" required_modules: - "llm_secret_detector" - -supported_volume_modes: - - "ro" diff --git a/backend/toolbox/workflows/llm_secret_detection/workflow.py b/backend/toolbox/workflows/llm_secret_detection/workflow.py index 4f693d0..a0c66d2 100644 --- a/backend/toolbox/workflows/llm_secret_detection/workflow.py +++ b/backend/toolbox/workflows/llm_secret_detection/workflow.py @@ -17,6 +17,7 @@ class LlmSecretDetectionWorkflow: llm_model: Optional[str] = None, llm_provider: Optional[str] = None, max_files: Optional[int] = None, + max_file_size: Optional[int] = None, timeout: Optional[int] = None, file_patterns: Optional[list] = None ) -> Dict[str, Any]: @@ -67,6 +68,8 @@ class LlmSecretDetectionWorkflow: config["llm_provider"] = llm_provider if max_files: config["max_files"] = max_files + if max_file_size: + config["max_file_size"] = max_file_size if timeout: config["timeout"] = timeout if file_patterns: diff --git a/backend/toolbox/workflows/ossfuzz_campaign/metadata.yaml b/backend/toolbox/workflows/ossfuzz_campaign/metadata.yaml index fbc1d51..d6766f9 100644 --- a/backend/toolbox/workflows/ossfuzz_campaign/metadata.yaml +++ b/backend/toolbox/workflows/ossfuzz_campaign/metadata.yaml @@ -16,13 +16,6 @@ tags: # OSS-Fuzz campaigns use isolated mode for safe concurrent campaigns workspace_isolation: "isolated" -default_parameters: - project_name: null - campaign_duration_hours: 1 - override_engine: null - override_sanitizer: null - max_iterations: null - parameters: type: object required: diff --git a/backend/toolbox/workflows/python_sast/__init__.py b/backend/toolbox/workflows/python_sast/__init__.py new file mode 100644 index 0000000..e436884 --- /dev/null +++ b/backend/toolbox/workflows/python_sast/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. diff --git a/backend/toolbox/workflows/python_sast/activities.py b/backend/toolbox/workflows/python_sast/activities.py new file mode 100644 index 0000000..fea884f --- /dev/null +++ b/backend/toolbox/workflows/python_sast/activities.py @@ -0,0 +1,191 @@ +""" +Python SAST Workflow Activities + +Activities specific to the Python SAST workflow: +- scan_dependencies_activity: Scan Python dependencies for CVEs using pip-audit +- analyze_with_bandit_activity: Analyze Python code for security issues using Bandit +- analyze_with_mypy_activity: Analyze Python code for type safety using Mypy +- generate_python_sast_sarif_activity: Generate SARIF report from all findings +""" + +import logging +import sys +from pathlib import Path + +from temporalio import activity + +# Configure logging +logger = logging.getLogger(__name__) + +# Add toolbox to path for module imports +sys.path.insert(0, '/app/toolbox') + + +@activity.defn(name="scan_dependencies") +async def scan_dependencies_activity(workspace_path: str, config: dict) -> dict: + """ + Scan Python dependencies for known vulnerabilities using pip-audit. + + Args: + workspace_path: Path to the workspace directory + config: DependencyScanner configuration + + Returns: + Scanner results dictionary + """ + logger.info(f"Activity: scan_dependencies (workspace={workspace_path})") + + try: + from modules.scanner import DependencyScanner + + workspace = Path(workspace_path) + if not workspace.exists(): + raise FileNotFoundError(f"Workspace not found: {workspace_path}") + + scanner = DependencyScanner() + result = await scanner.execute(config, workspace) + + logger.info( + f"✓ Dependency scanning completed: " + f"{result.summary.get('total_vulnerabilities', 0)} vulnerabilities found" + ) + return result.dict() + + except Exception as e: + logger.error(f"Dependency scanning failed: {e}", exc_info=True) + raise + + +@activity.defn(name="analyze_with_bandit") +async def analyze_with_bandit_activity(workspace_path: str, config: dict) -> dict: + """ + Analyze Python code for security issues using Bandit. + + Args: + workspace_path: Path to the workspace directory + config: BanditAnalyzer configuration + + Returns: + Analysis results dictionary + """ + logger.info(f"Activity: analyze_with_bandit (workspace={workspace_path})") + + try: + from modules.analyzer import BanditAnalyzer + + workspace = Path(workspace_path) + if not workspace.exists(): + raise FileNotFoundError(f"Workspace not found: {workspace_path}") + + analyzer = BanditAnalyzer() + result = await analyzer.execute(config, workspace) + + logger.info( + f"✓ Bandit analysis completed: " + f"{result.summary.get('total_issues', 0)} security issues found" + ) + return result.dict() + + except Exception as e: + logger.error(f"Bandit analysis failed: {e}", exc_info=True) + raise + + +@activity.defn(name="analyze_with_mypy") +async def analyze_with_mypy_activity(workspace_path: str, config: dict) -> dict: + """ + Analyze Python code for type safety issues using Mypy. + + Args: + workspace_path: Path to the workspace directory + config: MypyAnalyzer configuration + + Returns: + Analysis results dictionary + """ + logger.info(f"Activity: analyze_with_mypy (workspace={workspace_path})") + + try: + from modules.analyzer import MypyAnalyzer + + workspace = Path(workspace_path) + if not workspace.exists(): + raise FileNotFoundError(f"Workspace not found: {workspace_path}") + + analyzer = MypyAnalyzer() + result = await analyzer.execute(config, workspace) + + logger.info( + f"✓ Mypy analysis completed: " + f"{result.summary.get('total_errors', 0)} type errors found" + ) + return result.dict() + + except Exception as e: + logger.error(f"Mypy analysis failed: {e}", exc_info=True) + raise + + +@activity.defn(name="generate_python_sast_sarif") +async def generate_python_sast_sarif_activity( + dependency_results: dict, + bandit_results: dict, + mypy_results: dict, + config: dict, + workspace_path: str +) -> dict: + """ + Generate SARIF report from all SAST analysis results. + + Args: + dependency_results: Results from dependency scanner + bandit_results: Results from Bandit analyzer + mypy_results: Results from Mypy analyzer + config: Reporter configuration + workspace_path: Path to the workspace + + Returns: + SARIF report dictionary + """ + logger.info("Activity: generate_python_sast_sarif") + + try: + from modules.reporter import SARIFReporter + + workspace = Path(workspace_path) + + # Combine findings from all modules + all_findings = [] + + # Add dependency scanner findings + dependency_findings = dependency_results.get("findings", []) + all_findings.extend(dependency_findings) + + # Add Bandit findings + bandit_findings = bandit_results.get("findings", []) + all_findings.extend(bandit_findings) + + # Add Mypy findings + mypy_findings = mypy_results.get("findings", []) + all_findings.extend(mypy_findings) + + # Prepare reporter config + reporter_config = { + **config, + "findings": all_findings, + "tool_name": "FuzzForge Python SAST", + "tool_version": "1.0.0" + } + + reporter = SARIFReporter() + result = await reporter.execute(reporter_config, workspace) + + # Extract SARIF from result + sarif = result.dict().get("sarif", {}) + + logger.info(f"✓ SARIF report generated with {len(all_findings)} findings") + return sarif + + except Exception as e: + logger.error(f"SARIF report generation failed: {e}", exc_info=True) + raise diff --git a/backend/toolbox/workflows/python_sast/metadata.yaml b/backend/toolbox/workflows/python_sast/metadata.yaml new file mode 100644 index 0000000..c7e209c --- /dev/null +++ b/backend/toolbox/workflows/python_sast/metadata.yaml @@ -0,0 +1,110 @@ +name: python_sast +version: "1.0.0" +vertical: python +description: "Python Static Application Security Testing (SAST) workflow combining dependency scanning (pip-audit), security linting (Bandit), and type checking (Mypy)" +author: "FuzzForge Team" +tags: + - "python" + - "sast" + - "security" + - "type-checking" + - "dependencies" + - "bandit" + - "mypy" + - "pip-audit" + - "sarif" + +# Workspace isolation mode (system-level configuration) +# Using "shared" mode for read-only SAST analysis (no file modifications) +workspace_isolation: "shared" + +parameters: + type: object + properties: + dependency_config: + type: object + description: "Dependency scanner (pip-audit) configuration" + properties: + dependency_files: + type: array + items: + type: string + description: "List of dependency files to scan (auto-discovered if empty)" + default: [] + ignore_vulns: + type: array + items: + type: string + description: "List of vulnerability IDs to ignore" + default: [] + bandit_config: + type: object + description: "Bandit security analyzer configuration" + properties: + severity_level: + type: string + enum: ["low", "medium", "high"] + description: "Minimum severity level to report" + default: "low" + confidence_level: + type: string + enum: ["low", "medium", "high"] + description: "Minimum confidence level to report" + default: "medium" + exclude_tests: + type: boolean + description: "Exclude test files from analysis" + default: true + skip_ids: + type: array + items: + type: string + description: "List of Bandit test IDs to skip" + default: [] + mypy_config: + type: object + description: "Mypy type checker configuration" + properties: + strict_mode: + type: boolean + description: "Enable strict type checking" + default: false + ignore_missing_imports: + type: boolean + description: "Ignore errors about missing imports" + default: true + follow_imports: + type: string + enum: ["normal", "silent", "skip", "error"] + description: "How to handle imports" + default: "silent" + reporter_config: + type: object + description: "SARIF reporter configuration" + properties: + include_code_flows: + type: boolean + description: "Include code flow information" + default: false + +output_schema: + type: object + properties: + sarif: + type: object + description: "SARIF-formatted SAST findings from all tools" + summary: + type: object + description: "SAST execution summary" + properties: + total_findings: + type: integer + vulnerabilities: + type: integer + description: "CVEs found in dependencies" + security_issues: + type: integer + description: "Security issues found by Bandit" + type_errors: + type: integer + description: "Type errors found by Mypy" diff --git a/backend/toolbox/workflows/python_sast/workflow.py b/backend/toolbox/workflows/python_sast/workflow.py new file mode 100644 index 0000000..6d56a47 --- /dev/null +++ b/backend/toolbox/workflows/python_sast/workflow.py @@ -0,0 +1,265 @@ +""" +Python SAST Workflow - Temporal Version + +Static Application Security Testing for Python projects using multiple tools. +""" + +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +from datetime import timedelta +from typing import Dict, Any, Optional + +from temporalio import workflow +from temporalio.common import RetryPolicy + +# Import activity interfaces (will be executed by worker) +with workflow.unsafe.imports_passed_through(): + import logging + +logger = logging.getLogger(__name__) + + +@workflow.defn +class PythonSastWorkflow: + """ + Python Static Application Security Testing workflow. + + This workflow: + 1. Downloads target from MinIO + 2. Runs dependency scanning (pip-audit for CVEs) + 3. Runs security linting (Bandit for security issues) + 4. Runs type checking (Mypy for type safety) + 5. Generates a SARIF report with all findings + 6. Uploads results to MinIO + 7. Cleans up cache + """ + + @workflow.run + async def run( + self, + target_id: str, + dependency_config: Optional[Dict[str, Any]] = None, + bandit_config: Optional[Dict[str, Any]] = None, + mypy_config: Optional[Dict[str, Any]] = None, + reporter_config: Optional[Dict[str, Any]] = None + ) -> Dict[str, Any]: + """ + Main workflow execution. + + Args: + target_id: UUID of the uploaded target in MinIO + dependency_config: Configuration for dependency scanner + bandit_config: Configuration for Bandit analyzer + mypy_config: Configuration for Mypy analyzer + reporter_config: Configuration for SARIF reporter + + Returns: + Dictionary containing SARIF report and summary + """ + workflow_id = workflow.info().workflow_id + + workflow.logger.info( + f"Starting PythonSASTWorkflow " + f"(workflow_id={workflow_id}, target_id={target_id})" + ) + + # Default configurations + if not dependency_config: + dependency_config = { + "dependency_files": [], # Auto-discover + "ignore_vulns": [] + } + + if not bandit_config: + bandit_config = { + "severity_level": "low", + "confidence_level": "medium", + "exclude_tests": True, + "skip_ids": [] + } + + if not mypy_config: + mypy_config = { + "strict_mode": False, + "ignore_missing_imports": True, + "follow_imports": "silent" + } + + if not reporter_config: + reporter_config = { + "include_code_flows": False + } + + results = { + "workflow_id": workflow_id, + "target_id": target_id, + "status": "running", + "steps": [] + } + + try: + # Get run ID for workspace isolation (using shared mode for read-only analysis) + run_id = workflow.info().run_id + + # Step 1: Download target from MinIO + workflow.logger.info("Step 1: Downloading target from MinIO") + target_path = await workflow.execute_activity( + "get_target", + args=[target_id, run_id, "shared"], # target_id, run_id, workspace_isolation + start_to_close_timeout=timedelta(minutes=5), + retry_policy=RetryPolicy( + initial_interval=timedelta(seconds=1), + maximum_interval=timedelta(seconds=30), + maximum_attempts=3 + ) + ) + results["steps"].append({ + "step": "download_target", + "status": "success", + "target_path": target_path + }) + workflow.logger.info(f"✓ Target downloaded to: {target_path}") + + # Step 2: Dependency scanning (pip-audit) + workflow.logger.info("Step 2: Scanning dependencies for vulnerabilities") + dependency_results = await workflow.execute_activity( + "scan_dependencies", + args=[target_path, dependency_config], + start_to_close_timeout=timedelta(minutes=10), + retry_policy=RetryPolicy( + initial_interval=timedelta(seconds=2), + maximum_interval=timedelta(seconds=60), + maximum_attempts=2 + ) + ) + results["steps"].append({ + "step": "dependency_scanning", + "status": "success", + "vulnerabilities": dependency_results.get("summary", {}).get("total_vulnerabilities", 0) + }) + workflow.logger.info( + f"✓ Dependency scanning completed: " + f"{dependency_results.get('summary', {}).get('total_vulnerabilities', 0)} vulnerabilities" + ) + + # Step 3: Security linting (Bandit) + workflow.logger.info("Step 3: Analyzing security issues with Bandit") + bandit_results = await workflow.execute_activity( + "analyze_with_bandit", + args=[target_path, bandit_config], + start_to_close_timeout=timedelta(minutes=10), + retry_policy=RetryPolicy( + initial_interval=timedelta(seconds=2), + maximum_interval=timedelta(seconds=60), + maximum_attempts=2 + ) + ) + results["steps"].append({ + "step": "bandit_analysis", + "status": "success", + "issues": bandit_results.get("summary", {}).get("total_issues", 0) + }) + workflow.logger.info( + f"✓ Bandit analysis completed: " + f"{bandit_results.get('summary', {}).get('total_issues', 0)} security issues" + ) + + # Step 4: Type checking (Mypy) + workflow.logger.info("Step 4: Type checking with Mypy") + mypy_results = await workflow.execute_activity( + "analyze_with_mypy", + args=[target_path, mypy_config], + start_to_close_timeout=timedelta(minutes=10), + retry_policy=RetryPolicy( + initial_interval=timedelta(seconds=2), + maximum_interval=timedelta(seconds=60), + maximum_attempts=2 + ) + ) + results["steps"].append({ + "step": "mypy_analysis", + "status": "success", + "type_errors": mypy_results.get("summary", {}).get("total_errors", 0) + }) + workflow.logger.info( + f"✓ Mypy analysis completed: " + f"{mypy_results.get('summary', {}).get('total_errors', 0)} type errors" + ) + + # Step 5: Generate SARIF report + workflow.logger.info("Step 5: Generating SARIF report") + sarif_report = await workflow.execute_activity( + "generate_python_sast_sarif", + args=[dependency_results, bandit_results, mypy_results, reporter_config, target_path], + start_to_close_timeout=timedelta(minutes=5) + ) + results["steps"].append({ + "step": "report_generation", + "status": "success" + }) + + # Count total findings in SARIF + total_findings = 0 + if sarif_report and "runs" in sarif_report: + total_findings = len(sarif_report["runs"][0].get("results", [])) + + workflow.logger.info(f"✓ SARIF report generated with {total_findings} findings") + + # Step 6: Upload results to MinIO + workflow.logger.info("Step 6: Uploading results") + try: + results_url = await workflow.execute_activity( + "upload_results", + args=[workflow_id, sarif_report, "sarif"], + start_to_close_timeout=timedelta(minutes=2) + ) + results["results_url"] = results_url + workflow.logger.info(f"✓ Results uploaded to: {results_url}") + except Exception as e: + workflow.logger.warning(f"Failed to upload results: {e}") + results["results_url"] = None + + # Step 7: Cleanup cache + workflow.logger.info("Step 7: Cleaning up cache") + try: + await workflow.execute_activity( + "cleanup_cache", + args=[target_path, "shared"], # target_path, workspace_isolation + start_to_close_timeout=timedelta(minutes=1) + ) + workflow.logger.info("✓ Cache cleaned up (skipped for shared mode)") + except Exception as e: + workflow.logger.warning(f"Cache cleanup failed: {e}") + + # Mark workflow as successful + results["status"] = "success" + results["sarif"] = sarif_report + results["summary"] = { + "total_findings": total_findings, + "vulnerabilities": dependency_results.get("summary", {}).get("total_vulnerabilities", 0), + "security_issues": bandit_results.get("summary", {}).get("total_issues", 0), + "type_errors": mypy_results.get("summary", {}).get("total_errors", 0) + } + workflow.logger.info(f"✓ Workflow completed successfully: {workflow_id}") + + return results + + except Exception as e: + workflow.logger.error(f"Workflow failed: {e}") + results["status"] = "error" + results["error"] = str(e) + results["steps"].append({ + "step": "error", + "status": "failed", + "error": str(e) + }) + raise diff --git a/backend/toolbox/workflows/security_assessment/metadata.yaml b/backend/toolbox/workflows/security_assessment/metadata.yaml index 572e50c..09addbd 100644 --- a/backend/toolbox/workflows/security_assessment/metadata.yaml +++ b/backend/toolbox/workflows/security_assessment/metadata.yaml @@ -18,11 +18,6 @@ tags: # Using "shared" mode for read-only security analysis (no file modifications) workspace_isolation: "shared" -default_parameters: - scanner_config: {} - analyzer_config: {} - reporter_config: {} - parameters: type: object properties: diff --git a/backend/toolbox/workflows/trufflehog_detection/metadata.yaml b/backend/toolbox/workflows/trufflehog_detection/metadata.yaml index 1a147f0..d725061 100644 --- a/backend/toolbox/workflows/trufflehog_detection/metadata.yaml +++ b/backend/toolbox/workflows/trufflehog_detection/metadata.yaml @@ -23,12 +23,5 @@ parameters: default: 10 description: "Maximum directory depth to scan" -default_parameters: - verify: true - max_depth: 10 - required_modules: - "trufflehog" - -supported_volume_modes: - - "ro" diff --git a/cli/pyproject.toml b/cli/pyproject.toml index 1b8ddd9..4a71d1e 100644 --- a/cli/pyproject.toml +++ b/cli/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "fuzzforge-cli" -version = "0.7.0" +version = "0.7.3" description = "FuzzForge CLI - Command-line interface for FuzzForge security testing platform" readme = "README.md" authors = [ diff --git a/cli/src/fuzzforge_cli/__init__.py b/cli/src/fuzzforge_cli/__init__.py index 9d26c75..cc4a071 100644 --- a/cli/src/fuzzforge_cli/__init__.py +++ b/cli/src/fuzzforge_cli/__init__.py @@ -16,4 +16,4 @@ with local project management and persistent storage. # Additional attribution and requirements are provided in the NOTICE file. -__version__ = "0.6.0" \ No newline at end of file +__version__ = "0.7.3" \ No newline at end of file diff --git a/cli/src/fuzzforge_cli/commands/__init__.py b/cli/src/fuzzforge_cli/commands/__init__.py index 7e53182..afcf0d9 100644 --- a/cli/src/fuzzforge_cli/commands/__init__.py +++ b/cli/src/fuzzforge_cli/commands/__init__.py @@ -12,3 +12,6 @@ Command modules for FuzzForge CLI. # # Additional attribution and requirements are provided in the NOTICE file. +from . import worker + +__all__ = ["worker"] diff --git a/cli/src/fuzzforge_cli/commands/findings.py b/cli/src/fuzzforge_cli/commands/findings.py index 6335db1..7058527 100644 --- a/cli/src/fuzzforge_cli/commands/findings.py +++ b/cli/src/fuzzforge_cli/commands/findings.py @@ -253,15 +253,15 @@ def display_finding_detail(finding: Dict[str, Any], tool: Dict[str, Any], run_id content_lines.append(f"[bold]Tool:[/bold] {tool.get('name', 'Unknown')} v{tool.get('version', 'unknown')}") content_lines.append(f"[bold]Run ID:[/bold] {run_id}") content_lines.append("") - content_lines.append(f"[bold]Summary:[/bold]") + content_lines.append("[bold]Summary:[/bold]") content_lines.append(message_text) content_lines.append("") - content_lines.append(f"[bold]Description:[/bold]") + content_lines.append("[bold]Description:[/bold]") content_lines.append(message_markdown) if code_snippet: content_lines.append("") - content_lines.append(f"[bold]Code Snippet:[/bold]") + content_lines.append("[bold]Code Snippet:[/bold]") content_lines.append(f"[dim]{code_snippet}[/dim]") content = "\n".join(content_lines) @@ -270,7 +270,7 @@ def display_finding_detail(finding: Dict[str, Any], tool: Dict[str, Any], run_id console.print() console.print(Panel( content, - title=f"🔍 Finding Detail", + title="🔍 Finding Detail", border_style=severity_color, box=box.ROUNDED, padding=(1, 2) diff --git a/cli/src/fuzzforge_cli/commands/init.py b/cli/src/fuzzforge_cli/commands/init.py index 9aa4ca7..ceb3586 100644 --- a/cli/src/fuzzforge_cli/commands/init.py +++ b/cli/src/fuzzforge_cli/commands/init.py @@ -187,19 +187,40 @@ def _ensure_env_file(fuzzforge_dir: Path, force: bool) -> None: console.print("🧠 Configuring AI environment...") console.print(" • Default LLM provider: openai") - console.print(" • Default LLM model: gpt-5-mini") + console.print(" • Default LLM model: litellm_proxy/gpt-5-mini") console.print(" • To customise provider/model later, edit .fuzzforge/.env") llm_provider = "openai" - llm_model = "gpt-5-mini" + llm_model = "litellm_proxy/gpt-5-mini" + + # Check for global virtual keys from volumes/env/.env + global_env_key = None + for parent in fuzzforge_dir.parents: + global_env = parent / "volumes" / "env" / ".env" + if global_env.exists(): + try: + for line in global_env.read_text(encoding="utf-8").splitlines(): + if line.strip().startswith("OPENAI_API_KEY=") and "=" in line: + key_value = line.split("=", 1)[1].strip() + if key_value and not key_value.startswith("your-") and key_value.startswith("sk-"): + global_env_key = key_value + console.print(f" • Found virtual key in {global_env.relative_to(parent)}") + break + except Exception: + pass + break api_key = Prompt.ask( - "OpenAI API key (leave blank to fill manually)", + "OpenAI API key (leave blank to use global virtual key)" if global_env_key else "OpenAI API key (leave blank to fill manually)", default="", show_default=False, console=console, ) + # Use global key if user didn't provide one + if not api_key and global_env_key: + api_key = global_env_key + session_db_path = fuzzforge_dir / "fuzzforge_sessions.db" session_db_rel = session_db_path.relative_to(fuzzforge_dir.parent) @@ -210,14 +231,20 @@ def _ensure_env_file(fuzzforge_dir: Path, force: bool) -> None: f"LLM_PROVIDER={llm_provider}", f"LLM_MODEL={llm_model}", f"LITELLM_MODEL={llm_model}", + "LLM_ENDPOINT=http://localhost:10999", + "LLM_API_KEY=", + "LLM_EMBEDDING_MODEL=litellm_proxy/text-embedding-3-large", + "LLM_EMBEDDING_ENDPOINT=http://localhost:10999", f"OPENAI_API_KEY={api_key}", "FUZZFORGE_MCP_URL=http://localhost:8010/mcp", "", "# Cognee configuration mirrors the primary LLM by default", f"LLM_COGNEE_PROVIDER={llm_provider}", f"LLM_COGNEE_MODEL={llm_model}", - f"LLM_COGNEE_API_KEY={api_key}", - "LLM_COGNEE_ENDPOINT=", + "LLM_COGNEE_ENDPOINT=http://localhost:10999", + "LLM_COGNEE_API_KEY=", + "LLM_COGNEE_EMBEDDING_MODEL=litellm_proxy/text-embedding-3-large", + "LLM_COGNEE_EMBEDDING_ENDPOINT=http://localhost:10999", "COGNEE_MCP_URL=", "", "# Session persistence options: inmemory | sqlite", @@ -239,6 +266,8 @@ def _ensure_env_file(fuzzforge_dir: Path, force: bool) -> None: for line in env_lines: if line.startswith("OPENAI_API_KEY="): template_lines.append("OPENAI_API_KEY=") + elif line.startswith("LLM_API_KEY="): + template_lines.append("LLM_API_KEY=") elif line.startswith("LLM_COGNEE_API_KEY="): template_lines.append("LLM_COGNEE_API_KEY=") else: diff --git a/cli/src/fuzzforge_cli/commands/worker.py b/cli/src/fuzzforge_cli/commands/worker.py new file mode 100644 index 0000000..06b8b03 --- /dev/null +++ b/cli/src/fuzzforge_cli/commands/worker.py @@ -0,0 +1,225 @@ +""" +Worker management commands for FuzzForge CLI. + +Provides commands to start, stop, and list Temporal workers. +""" +# Copyright (c) 2025 FuzzingLabs +# +# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file +# at the root of this repository for details. +# +# After the Change Date (four years from publication), this version of the +# Licensed Work will be made available under the Apache License, Version 2.0. +# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0 +# +# Additional attribution and requirements are provided in the NOTICE file. + +import subprocess +import sys +import typer +from pathlib import Path +from rich.console import Console +from rich.table import Table +from typing import Optional + +from ..worker_manager import WorkerManager + +console = Console() +app = typer.Typer( + name="worker", + help="🔧 Manage Temporal workers", + no_args_is_help=True, +) + + +@app.command("stop") +def stop_workers( + all: bool = typer.Option( + False, "--all", + help="Stop all workers (default behavior, flag for clarity)" + ) +): + """ + 🛑 Stop all running FuzzForge workers. + + This command stops all worker containers using the proper Docker Compose + profile flag to ensure workers are actually stopped (since they're in profiles). + + Examples: + $ ff worker stop + $ ff worker stop --all + """ + try: + worker_mgr = WorkerManager() + success = worker_mgr.stop_all_workers() + + if success: + sys.exit(0) + else: + console.print("⚠️ Some workers may not have stopped properly", style="yellow") + sys.exit(1) + + except Exception as e: + console.print(f"❌ Error: {e}", style="red") + sys.exit(1) + + +@app.command("list") +def list_workers( + all: bool = typer.Option( + False, "--all", "-a", + help="Show all workers (including stopped)" + ) +): + """ + 📋 List FuzzForge workers and their status. + + By default, shows only running workers. Use --all to see all workers. + + Examples: + $ ff worker list + $ ff worker list --all + """ + try: + # Get list of running workers + result = subprocess.run( + ["docker", "ps", "--filter", "name=fuzzforge-worker-", + "--format", "{{.Names}}\t{{.Status}}\t{{.RunningFor}}"], + capture_output=True, + text=True, + check=False + ) + + running_workers = [] + if result.stdout.strip(): + for line in result.stdout.strip().splitlines(): + parts = line.split('\t') + if len(parts) >= 3: + running_workers.append({ + "name": parts[0].replace("fuzzforge-worker-", ""), + "status": "Running", + "uptime": parts[2] + }) + + # If --all, also get stopped workers + stopped_workers = [] + if all: + result_all = subprocess.run( + ["docker", "ps", "-a", "--filter", "name=fuzzforge-worker-", + "--format", "{{.Names}}\t{{.Status}}"], + capture_output=True, + text=True, + check=False + ) + + all_worker_names = set() + for line in result_all.stdout.strip().splitlines(): + parts = line.split('\t') + if len(parts) >= 2: + worker_name = parts[0].replace("fuzzforge-worker-", "") + all_worker_names.add(worker_name) + # If not running, it's stopped + if not any(w["name"] == worker_name for w in running_workers): + stopped_workers.append({ + "name": worker_name, + "status": "Stopped", + "uptime": "-" + }) + + # Display results + if not running_workers and not stopped_workers: + console.print("ℹ️ No workers found", style="cyan") + console.print("\n💡 Start a worker with: [cyan]docker compose up -d worker-[/cyan]") + console.print(" Or run a workflow, which auto-starts workers: [cyan]ff workflow run [/cyan]") + return + + # Create table + table = Table(title="FuzzForge Workers", show_header=True, header_style="bold cyan") + table.add_column("Worker", style="cyan", no_wrap=True) + table.add_column("Status", style="green") + table.add_column("Uptime", style="dim") + + # Add running workers + for worker in running_workers: + table.add_row( + worker["name"], + f"[green]●[/green] {worker['status']}", + worker["uptime"] + ) + + # Add stopped workers if --all + for worker in stopped_workers: + table.add_row( + worker["name"], + f"[red]●[/red] {worker['status']}", + worker["uptime"] + ) + + console.print(table) + + # Summary + if running_workers: + console.print(f"\n✅ {len(running_workers)} worker(s) running") + if stopped_workers: + console.print(f"⏹️ {len(stopped_workers)} worker(s) stopped") + + except Exception as e: + console.print(f"❌ Error listing workers: {e}", style="red") + sys.exit(1) + + +@app.command("start") +def start_worker( + name: str = typer.Argument( + ..., + help="Worker name (e.g., 'python', 'android', 'secrets')" + ), + build: bool = typer.Option( + False, "--build", + help="Rebuild worker image before starting" + ) +): + """ + 🚀 Start a specific worker. + + The worker name should be the vertical name (e.g., 'python', 'android', 'rust'). + + Examples: + $ ff worker start python + $ ff worker start android --build + """ + try: + service_name = f"worker-{name}" + + console.print(f"🚀 Starting worker: [cyan]{service_name}[/cyan]") + + # Build docker compose command + cmd = ["docker", "compose", "up", "-d"] + if build: + cmd.append("--build") + cmd.append(service_name) + + result = subprocess.run( + cmd, + capture_output=True, + text=True, + check=False + ) + + if result.returncode == 0: + console.print(f"✅ Worker [cyan]{service_name}[/cyan] started successfully") + else: + console.print(f"❌ Failed to start worker: {result.stderr}", style="red") + console.print( + f"\n💡 Try manually: [yellow]docker compose up -d {service_name}[/yellow]", + style="dim" + ) + sys.exit(1) + + except Exception as e: + console.print(f"❌ Error: {e}", style="red") + sys.exit(1) + + +if __name__ == "__main__": + app() diff --git a/cli/src/fuzzforge_cli/commands/workflow_exec.py b/cli/src/fuzzforge_cli/commands/workflow_exec.py index d1633e8..bfa7f12 100644 --- a/cli/src/fuzzforge_cli/commands/workflow_exec.py +++ b/cli/src/fuzzforge_cli/commands/workflow_exec.py @@ -39,7 +39,7 @@ from ..validation import ( ) from ..progress import step_progress from ..constants import ( - STATUS_EMOJIS, MAX_RUN_ID_DISPLAY_LENGTH, DEFAULT_VOLUME_MODE, + STATUS_EMOJIS, MAX_RUN_ID_DISPLAY_LENGTH, PROGRESS_STEP_DELAYS, MAX_RETRIES, RETRY_DELAY, POLL_INTERVAL ) from ..worker_manager import WorkerManager @@ -112,7 +112,6 @@ def execute_workflow_submission( workflow: str, target_path: str, parameters: Dict[str, Any], - volume_mode: str, timeout: Optional[int], interactive: bool ) -> Any: @@ -160,13 +159,10 @@ def execute_workflow_submission( except ValueError as e: console.print(f"❌ Invalid {param_type}: {e}", style="red") - # Note: volume_mode is no longer used (Temporal uses MinIO storage) - # Show submission summary console.print("\n🎯 [bold]Executing workflow:[/bold]") console.print(f" Workflow: {workflow}") console.print(f" Target: {target_path}") - console.print(f" Volume Mode: {volume_mode}") if parameters: console.print(f" Parameters: {len(parameters)} provided") if timeout: @@ -252,8 +248,6 @@ def execute_workflow_submission( progress.next_step() # Submitting submission = WorkflowSubmission( - target_path=target_path, - volume_mode=volume_mode, parameters=parameters, timeout=timeout ) @@ -281,10 +275,6 @@ def execute_workflow( None, "--param-file", "-f", help="JSON file containing workflow parameters" ), - volume_mode: str = typer.Option( - DEFAULT_VOLUME_MODE, "--volume-mode", "-v", - help="Volume mount mode: ro (read-only) or rw (read-write)" - ), timeout: Optional[int] = typer.Option( None, "--timeout", "-t", help="Execution timeout in seconds" @@ -410,7 +400,7 @@ def execute_workflow( response = execute_workflow_submission( client, workflow, target_path, parameters, - volume_mode, timeout, interactive + timeout, interactive ) console.print("✅ Workflow execution started!", style="green") @@ -453,9 +443,9 @@ def execute_workflow( console.print("Press Ctrl+C to stop monitoring (execution continues in background).\n") try: - from ..commands.monitor import live_monitor - # Import monitor command and run it - live_monitor(response.run_id, refresh=3) + from ..commands.monitor import _live_monitor + # Call helper function directly with proper parameters + _live_monitor(response.run_id, refresh=3, once=False, style="inline") except KeyboardInterrupt: console.print("\n⏹️ Live monitoring stopped (execution continues in background)", style="yellow") except Exception as e: diff --git a/cli/src/fuzzforge_cli/completion.py b/cli/src/fuzzforge_cli/completion.py index bd717cd..7bd7c5b 100644 --- a/cli/src/fuzzforge_cli/completion.py +++ b/cli/src/fuzzforge_cli/completion.py @@ -95,12 +95,6 @@ def complete_target_paths(incomplete: str) -> List[str]: return [] -def complete_volume_modes(incomplete: str) -> List[str]: - """Auto-complete volume mount modes.""" - modes = ["ro", "rw"] - return [mode for mode in modes if mode.startswith(incomplete)] - - def complete_export_formats(incomplete: str) -> List[str]: """Auto-complete export formats.""" formats = ["json", "csv", "html", "sarif"] @@ -139,7 +133,6 @@ def complete_config_keys(incomplete: str) -> List[str]: "api_url", "api_timeout", "default_workflow", - "default_volume_mode", "project_name", "data_retention_days", "auto_save_findings", @@ -164,11 +157,6 @@ TargetPathComplete = typer.Argument( help="Target path (tab completion available)" ) -VolumeModetComplete = typer.Option( - autocompletion=complete_volume_modes, - help="Volume mode: ro or rw (tab completion available)" -) - ExportFormatComplete = typer.Option( autocompletion=complete_export_formats, help="Export format (tab completion available)" diff --git a/cli/src/fuzzforge_cli/config.py b/cli/src/fuzzforge_cli/config.py index f21b87d..1a0ae28 100644 --- a/cli/src/fuzzforge_cli/config.py +++ b/cli/src/fuzzforge_cli/config.py @@ -28,6 +28,58 @@ try: # Optional dependency; fall back if not installed except ImportError: # pragma: no cover - optional dependency load_dotenv = None + +def _load_env_file_if_exists(path: Path, override: bool = False) -> bool: + if not path.exists(): + return False + # Always use manual parsing to handle empty values correctly + try: + for line in path.read_text(encoding="utf-8").splitlines(): + stripped = line.strip() + if not stripped or stripped.startswith("#") or "=" not in stripped: + continue + key, value = stripped.split("=", 1) + key = key.strip() + value = value.strip() + if override: + # Only override if value is non-empty + if value: + os.environ[key] = value + else: + # Set if not already in environment and value is non-empty + if key not in os.environ and value: + os.environ[key] = value + return True + except Exception: # pragma: no cover - best effort fallback + return False + + +def _find_shared_env_file(project_dir: Path) -> Path | None: + for directory in [project_dir] + list(project_dir.parents): + candidate = directory / "volumes" / "env" / ".env" + if candidate.exists(): + return candidate + return None + + +def load_project_env(project_dir: Optional[Path] = None) -> Path | None: + """Load project-local env, falling back to shared volumes/env/.env.""" + + project_dir = Path(project_dir or Path.cwd()) + shared_env = _find_shared_env_file(project_dir) + loaded_shared = False + if shared_env: + loaded_shared = _load_env_file_if_exists(shared_env, override=False) + + project_env = project_dir / ".fuzzforge" / ".env" + if _load_env_file_if_exists(project_env, override=True): + return project_env + + if loaded_shared: + return shared_env + + return None + import yaml from pydantic import BaseModel, Field @@ -312,23 +364,7 @@ class ProjectConfigManager: if not cognee.get("enabled", True): return - # Load project-specific environment overrides from .fuzzforge/.env if available - env_file = self.project_dir / ".fuzzforge" / ".env" - if env_file.exists(): - if load_dotenv: - load_dotenv(env_file, override=False) - else: - try: - for line in env_file.read_text(encoding="utf-8").splitlines(): - stripped = line.strip() - if not stripped or stripped.startswith("#"): - continue - if "=" not in stripped: - continue - key, value = stripped.split("=", 1) - os.environ.setdefault(key.strip(), value.strip()) - except Exception: # pragma: no cover - best effort fallback - pass + load_project_env(self.project_dir) backend_access = "true" if cognee.get("backend_access_control", True) else "false" os.environ["ENABLE_BACKEND_ACCESS_CONTROL"] = backend_access @@ -374,6 +410,17 @@ class ProjectConfigManager: "OPENAI_API_KEY", ) endpoint = _env("LLM_COGNEE_ENDPOINT", "COGNEE_LLM_ENDPOINT", "LLM_ENDPOINT") + embedding_model = _env( + "LLM_COGNEE_EMBEDDING_MODEL", + "COGNEE_LLM_EMBEDDING_MODEL", + "LLM_EMBEDDING_MODEL", + ) + embedding_endpoint = _env( + "LLM_COGNEE_EMBEDDING_ENDPOINT", + "COGNEE_LLM_EMBEDDING_ENDPOINT", + "LLM_EMBEDDING_ENDPOINT", + "LLM_ENDPOINT", + ) api_version = _env( "LLM_COGNEE_API_VERSION", "COGNEE_LLM_API_VERSION", @@ -398,6 +445,20 @@ class ProjectConfigManager: os.environ.setdefault("OPENAI_API_KEY", api_key) if endpoint: os.environ["LLM_ENDPOINT"] = endpoint + os.environ.setdefault("LLM_API_BASE", endpoint) + os.environ.setdefault("LLM_EMBEDDING_ENDPOINT", endpoint) + os.environ.setdefault("LLM_EMBEDDING_API_BASE", endpoint) + os.environ.setdefault("OPENAI_API_BASE", endpoint) + # Set LiteLLM proxy environment variables for SDK usage + os.environ.setdefault("LITELLM_PROXY_API_BASE", endpoint) + if api_key: + # Set LiteLLM proxy API key from the virtual key + os.environ.setdefault("LITELLM_PROXY_API_KEY", api_key) + if embedding_model: + os.environ["LLM_EMBEDDING_MODEL"] = embedding_model + if embedding_endpoint: + os.environ["LLM_EMBEDDING_ENDPOINT"] = embedding_endpoint + os.environ.setdefault("LLM_EMBEDDING_API_BASE", embedding_endpoint) if api_version: os.environ["LLM_API_VERSION"] = api_version if max_tokens: diff --git a/cli/src/fuzzforge_cli/constants.py b/cli/src/fuzzforge_cli/constants.py index 231f5b7..493dfb0 100644 --- a/cli/src/fuzzforge_cli/constants.py +++ b/cli/src/fuzzforge_cli/constants.py @@ -57,10 +57,6 @@ SEVERITY_STYLES = { "info": "bold cyan" } -# Default volume modes -DEFAULT_VOLUME_MODE = "ro" -SUPPORTED_VOLUME_MODES = ["ro", "rw"] - # Default export formats DEFAULT_EXPORT_FORMAT = "sarif" SUPPORTED_EXPORT_FORMATS = ["sarif", "json", "csv"] diff --git a/cli/src/fuzzforge_cli/fuzzy.py b/cli/src/fuzzforge_cli/fuzzy.py index 48f16a5..4cec4de 100644 --- a/cli/src/fuzzforge_cli/fuzzy.py +++ b/cli/src/fuzzforge_cli/fuzzy.py @@ -52,7 +52,6 @@ class FuzzyMatcher: # Common parameter names self.parameter_names = [ "target_path", - "volume_mode", "timeout", "workflow", "param", @@ -70,7 +69,6 @@ class FuzzyMatcher: # Common values self.common_values = { - "volume_mode": ["ro", "rw"], "format": ["json", "csv", "html", "sarif"], "severity": ["critical", "high", "medium", "low", "info"], } diff --git a/cli/src/fuzzforge_cli/main.py b/cli/src/fuzzforge_cli/main.py index 24baa9c..f869c8c 100644 --- a/cli/src/fuzzforge_cli/main.py +++ b/cli/src/fuzzforge_cli/main.py @@ -19,6 +19,8 @@ from rich.traceback import install from typing import Optional, List import sys +from .config import load_project_env + from .commands import ( workflows, workflow_exec, @@ -27,13 +29,16 @@ from .commands import ( config as config_cmd, ai, ingest, + worker, ) -from .constants import DEFAULT_VOLUME_MODE from .fuzzy import enhanced_command_not_found_handler # Install rich traceback handler install(show_locals=True) +# Ensure environment variables are available before command execution +load_project_env() + # Create console for rich output console = Console() @@ -184,10 +189,6 @@ def run_workflow( None, "--param-file", "-f", help="JSON file containing workflow parameters" ), - volume_mode: str = typer.Option( - DEFAULT_VOLUME_MODE, "--volume-mode", "-v", - help="Volume mount mode: ro (read-only) or rw (read-write)" - ), timeout: Optional[int] = typer.Option( None, "--timeout", "-t", help="Execution timeout in seconds" @@ -234,7 +235,6 @@ def run_workflow( target_path=target, params=params, param_file=param_file, - volume_mode=volume_mode, timeout=timeout, interactive=interactive, wait=wait, @@ -335,6 +335,7 @@ app.add_typer(finding_app, name="finding", help="🔍 View and analyze findings" app.add_typer(monitor.app, name="monitor", help="📊 Real-time monitoring") app.add_typer(ai.app, name="ai", help="🤖 AI integration features") app.add_typer(ingest.app, name="ingest", help="🧠 Ingest knowledge into AI") +app.add_typer(worker.app, name="worker", help="🔧 Manage Temporal workers") # Help and utility commands @app.command() @@ -410,7 +411,7 @@ def main(): 'init', 'status', 'config', 'clean', 'workflows', 'workflow', 'findings', 'finding', - 'monitor', 'ai', 'ingest', + 'monitor', 'ai', 'ingest', 'worker', 'version' ] diff --git a/cli/src/fuzzforge_cli/validation.py b/cli/src/fuzzforge_cli/validation.py index 1f524f6..b8fdfb7 100644 --- a/cli/src/fuzzforge_cli/validation.py +++ b/cli/src/fuzzforge_cli/validation.py @@ -17,7 +17,7 @@ import re from pathlib import Path from typing import Any, Dict, List, Optional -from .constants import SUPPORTED_VOLUME_MODES, SUPPORTED_EXPORT_FORMATS +from .constants import SUPPORTED_EXPORT_FORMATS from .exceptions import ValidationError @@ -65,15 +65,6 @@ def validate_target_path(target_path: str, must_exist: bool = True) -> Path: return path -def validate_volume_mode(volume_mode: str) -> None: - """Validate volume mode""" - if volume_mode not in SUPPORTED_VOLUME_MODES: - raise ValidationError( - "volume_mode", volume_mode, - f"one of: {', '.join(SUPPORTED_VOLUME_MODES)}" - ) - - def validate_export_format(export_format: str) -> None: """Validate export format""" if export_format not in SUPPORTED_EXPORT_FORMATS: diff --git a/cli/src/fuzzforge_cli/worker_manager.py b/cli/src/fuzzforge_cli/worker_manager.py index b6102e0..a9b3eaf 100644 --- a/cli/src/fuzzforge_cli/worker_manager.py +++ b/cli/src/fuzzforge_cli/worker_manager.py @@ -15,12 +15,17 @@ Manages on-demand startup and shutdown of Temporal workers using Docker Compose. # Additional attribution and requirements are provided in the NOTICE file. import logging +import os +import platform import subprocess import time from pathlib import Path from typing import Optional, Dict, Any +import requests +import yaml from rich.console import Console +from rich.status import Status logger = logging.getLogger(__name__) console = Console() @@ -57,27 +62,206 @@ class WorkerManager: def _find_compose_file(self) -> Path: """ - Auto-detect docker-compose.yml location. + Auto-detect docker-compose.yml location using multiple strategies. - Searches upward from current directory to find the compose file. + Strategies (in order): + 1. Query backend API for host path + 2. Search upward for .fuzzforge marker directory + 3. Use FUZZFORGE_ROOT environment variable + 4. Fallback to current directory + + Returns: + Path to docker-compose.yml + + Raises: + FileNotFoundError: If docker-compose.yml cannot be located """ - current = Path.cwd() + # Strategy 1: Ask backend for location + try: + backend_url = os.getenv("FUZZFORGE_API_URL", "http://localhost:8000") + response = requests.get(f"{backend_url}/system/info", timeout=2) + if response.ok: + info = response.json() + if compose_path_str := info.get("docker_compose_path"): + compose_path = Path(compose_path_str) + if compose_path.exists(): + logger.debug(f"Found docker-compose.yml via backend API: {compose_path}") + return compose_path + except Exception as e: + logger.debug(f"Backend API not reachable for path lookup: {e}") - # Try current directory and parents + # Strategy 2: Search upward for .fuzzforge marker directory + current = Path.cwd() for parent in [current] + list(current.parents): - compose_path = parent / "docker-compose.yml" + if (parent / ".fuzzforge").exists(): + compose_path = parent / "docker-compose.yml" + if compose_path.exists(): + logger.debug(f"Found docker-compose.yml via .fuzzforge marker: {compose_path}") + return compose_path + + # Strategy 3: Environment variable + if fuzzforge_root := os.getenv("FUZZFORGE_ROOT"): + compose_path = Path(fuzzforge_root) / "docker-compose.yml" if compose_path.exists(): + logger.debug(f"Found docker-compose.yml via FUZZFORGE_ROOT: {compose_path}") return compose_path - # Fallback to default location - return Path("docker-compose.yml") + # Strategy 4: Fallback to current directory + compose_path = Path("docker-compose.yml") + if compose_path.exists(): + return compose_path - def _run_docker_compose(self, *args: str) -> subprocess.CompletedProcess: + raise FileNotFoundError( + "Cannot find docker-compose.yml. Ensure backend is running, " + "run from FuzzForge directory, or set FUZZFORGE_ROOT environment variable." + ) + + def _get_workers_dir(self) -> Path: """ - Run docker-compose command. + Get the workers directory path. + + Uses same strategy as _find_compose_file(): + 1. Query backend API + 2. Derive from compose_file location + 3. Use FUZZFORGE_ROOT + + Returns: + Path to workers directory + """ + # Strategy 1: Ask backend + try: + backend_url = os.getenv("FUZZFORGE_API_URL", "http://localhost:8000") + response = requests.get(f"{backend_url}/system/info", timeout=2) + if response.ok: + info = response.json() + if workers_dir_str := info.get("workers_dir"): + workers_dir = Path(workers_dir_str) + if workers_dir.exists(): + return workers_dir + except Exception: + pass + + # Strategy 2: Derive from compose file location + if self.compose_file.exists(): + workers_dir = self.compose_file.parent / "workers" + if workers_dir.exists(): + return workers_dir + + # Strategy 3: Use environment variable + if fuzzforge_root := os.getenv("FUZZFORGE_ROOT"): + workers_dir = Path(fuzzforge_root) / "workers" + if workers_dir.exists(): + return workers_dir + + # Fallback + return Path("workers") + + def _detect_platform(self) -> str: + """ + Detect the current platform. + + Returns: + Platform string: "linux/amd64" or "linux/arm64" + """ + machine = platform.machine().lower() + system = platform.system().lower() + + logger.debug(f"Platform detection: machine={machine}, system={system}") + + # Normalize machine architecture + if machine in ["x86_64", "amd64", "x64"]: + detected = "linux/amd64" + elif machine in ["arm64", "aarch64", "armv8", "arm64v8"]: + detected = "linux/arm64" + else: + # Fallback to amd64 for unknown architectures + logger.warning( + f"Unknown architecture '{machine}' detected, falling back to linux/amd64. " + f"Please report this issue if you're experiencing problems." + ) + detected = "linux/amd64" + + logger.info(f"Detected platform: {detected}") + return detected + + def _read_worker_metadata(self, vertical: str) -> dict: + """ + Read worker metadata.yaml for a vertical. Args: - *args: Arguments to pass to docker-compose + vertical: Worker vertical name (e.g., "android", "python") + + Returns: + Dictionary containing metadata, or empty dict if not found + """ + try: + workers_dir = self._get_workers_dir() + metadata_file = workers_dir / vertical / "metadata.yaml" + + if not metadata_file.exists(): + logger.debug(f"No metadata.yaml found for {vertical}") + return {} + + with open(metadata_file, 'r') as f: + return yaml.safe_load(f) or {} + except Exception as e: + logger.debug(f"Failed to read metadata for {vertical}: {e}") + return {} + + def _select_dockerfile(self, vertical: str) -> str: + """ + Select the appropriate Dockerfile for the current platform. + + Args: + vertical: Worker vertical name + + Returns: + Dockerfile name (e.g., "Dockerfile.amd64", "Dockerfile.arm64") + """ + detected_platform = self._detect_platform() + metadata = self._read_worker_metadata(vertical) + + if not metadata: + # No metadata: use default Dockerfile + logger.debug(f"No metadata for {vertical}, using Dockerfile") + return "Dockerfile" + + platforms = metadata.get("platforms", {}) + + if not platforms: + # Metadata exists but no platform definitions + logger.debug(f"No platform definitions in metadata for {vertical}, using Dockerfile") + return "Dockerfile" + + # Try detected platform first + if detected_platform in platforms: + dockerfile = platforms[detected_platform].get("dockerfile", "Dockerfile") + logger.info(f"✓ Selected {dockerfile} for {vertical} on {detected_platform}") + return dockerfile + + # Fallback to default platform + default_platform = metadata.get("default_platform", "linux/amd64") + logger.warning( + f"Platform {detected_platform} not found in metadata for {vertical}, " + f"falling back to default: {default_platform}" + ) + + if default_platform in platforms: + dockerfile = platforms[default_platform].get("dockerfile", "Dockerfile.amd64") + logger.info(f"Using default platform {default_platform}: {dockerfile}") + return dockerfile + + # Last resort: just use Dockerfile + logger.warning(f"No suitable Dockerfile found for {vertical}, using 'Dockerfile'") + return "Dockerfile" + + def _run_docker_compose(self, *args: str, env: Optional[Dict[str, str]] = None) -> subprocess.CompletedProcess: + """ + Run docker compose command with optional environment variables. + + Args: + *args: Arguments to pass to docker compose + env: Optional environment variables to set Returns: CompletedProcess with result @@ -85,14 +269,21 @@ class WorkerManager: Raises: subprocess.CalledProcessError: If command fails """ - cmd = ["docker-compose", "-f", str(self.compose_file)] + list(args) + cmd = ["docker", "compose", "-f", str(self.compose_file)] + list(args) logger.debug(f"Running: {' '.join(cmd)}") + # Merge with current environment + full_env = os.environ.copy() + if env: + full_env.update(env) + logger.debug(f"Environment overrides: {env}") + return subprocess.run( cmd, capture_output=True, text=True, - check=True + check=True, + env=full_env ) def _service_to_container_name(self, service_name: str) -> str: @@ -135,21 +326,35 @@ class WorkerManager: def start_worker(self, service_name: str) -> bool: """ - Start a worker service using docker-compose. + Start a worker service using docker-compose with platform-specific Dockerfile. Args: - service_name: Name of the Docker Compose service to start (e.g., "worker-python") + service_name: Name of the Docker Compose service to start (e.g., "worker-android") Returns: True if started successfully, False otherwise """ try: - console.print(f"🚀 Starting worker: {service_name}") + # Extract vertical name from service name + vertical = service_name.replace("worker-", "") - # Use docker-compose up to create and start the service - result = self._run_docker_compose("up", "-d", service_name) + # Detect platform and select appropriate Dockerfile + detected_platform = self._detect_platform() + dockerfile = self._select_dockerfile(vertical) - logger.info(f"Worker {service_name} started") + # Set environment variable for docker-compose + env_var_name = f"{vertical.upper()}_DOCKERFILE" + env = {env_var_name: dockerfile} + + console.print( + f"🚀 Starting worker: {service_name} " + f"(platform: {detected_platform}, using {dockerfile})" + ) + + # Use docker-compose up with --build to ensure correct Dockerfile is used + result = self._run_docker_compose("up", "-d", "--build", service_name, env=env) + + logger.info(f"Worker {service_name} started with {dockerfile}") return True except subprocess.CalledProcessError as e: @@ -163,9 +368,67 @@ class WorkerManager: console.print(f"❌ Unexpected error: {e}", style="red") return False + def _get_container_state(self, service_name: str) -> str: + """ + Get the current state of a container (running, created, restarting, etc.). + + Args: + service_name: Name of the Docker Compose service + + Returns: + Container state string (running, created, restarting, exited, etc.) or "unknown" + """ + try: + container_name = self._service_to_container_name(service_name) + result = subprocess.run( + ["docker", "inspect", "-f", "{{.State.Status}}", container_name], + capture_output=True, + text=True, + check=False + ) + if result.returncode == 0: + return result.stdout.strip() + return "unknown" + except Exception as e: + logger.debug(f"Failed to get container state: {e}") + return "unknown" + + def _get_health_status(self, container_name: str) -> str: + """ + Get container health status. + + Args: + container_name: Docker container name + + Returns: + Health status: "healthy", "unhealthy", "starting", "none", or "unknown" + """ + try: + result = subprocess.run( + ["docker", "inspect", "-f", "{{.State.Health.Status}}", container_name], + capture_output=True, + text=True, + check=False + ) + + if result.returncode != 0: + return "unknown" + + health_status = result.stdout.strip() + + if health_status == "" or health_status == "": + return "none" # No health check defined + + return health_status # healthy, unhealthy, starting + + except Exception as e: + logger.debug(f"Failed to check health: {e}") + return "unknown" + def wait_for_worker_ready(self, service_name: str, timeout: Optional[int] = None) -> bool: """ Wait for a worker to be healthy and ready to process tasks. + Shows live progress updates during startup. Args: service_name: Name of the Docker Compose service @@ -173,56 +436,74 @@ class WorkerManager: Returns: True if worker is ready, False if timeout reached - - Raises: - TimeoutError: If worker doesn't become ready within timeout """ timeout = timeout or self.startup_timeout start_time = time.time() container_name = self._service_to_container_name(service_name) + last_status_msg = "" - console.print("⏳ Waiting for worker to be ready...") + with Status("[bold cyan]Starting worker...", console=console, spinner="dots") as status: + while time.time() - start_time < timeout: + elapsed = int(time.time() - start_time) + + # Get container state + container_state = self._get_container_state(service_name) + + # Get health status + health_status = self._get_health_status(container_name) + + # Build status message based on current state + if container_state == "created": + status_msg = f"[cyan]Worker starting... ({elapsed}s)[/cyan]" + elif container_state == "restarting": + status_msg = f"[yellow]Worker restarting... ({elapsed}s)[/yellow]" + elif container_state == "running": + if health_status == "starting": + status_msg = f"[cyan]Worker running, health check starting... ({elapsed}s)[/cyan]" + elif health_status == "unhealthy": + status_msg = f"[yellow]Worker running, health check: unhealthy ({elapsed}s)[/yellow]" + elif health_status == "healthy": + status_msg = f"[green]Worker healthy! ({elapsed}s)[/green]" + status.update(status_msg) + console.print(f"✅ Worker ready: {service_name} (took {elapsed}s)") + logger.info(f"Worker {service_name} is healthy (took {elapsed}s)") + return True + elif health_status == "none": + # No health check defined, assume ready + status_msg = f"[green]Worker running (no health check) ({elapsed}s)[/green]" + status.update(status_msg) + console.print(f"✅ Worker ready: {service_name} (took {elapsed}s)") + logger.info(f"Worker {service_name} is running, no health check (took {elapsed}s)") + return True + else: + status_msg = f"[cyan]Worker running ({elapsed}s)[/cyan]" + elif not container_state or container_state == "exited": + status_msg = f"[yellow]Waiting for container to start... ({elapsed}s)[/yellow]" + else: + status_msg = f"[cyan]Worker state: {container_state} ({elapsed}s)[/cyan]" + + # Show helpful hints at certain intervals + if elapsed == 10: + status_msg += " [dim](pulling image if not cached)[/dim]" + elif elapsed == 30: + status_msg += " [dim](large images can take time)[/dim]" + elif elapsed == 60: + status_msg += " [dim](still working...)[/dim]" + + # Update status if changed + if status_msg != last_status_msg: + status.update(status_msg) + last_status_msg = status_msg + logger.debug(f"Worker {service_name} - state: {container_state}, health: {health_status}") - while time.time() - start_time < timeout: - # Check if container is running - if not self.is_worker_running(service_name): - logger.debug(f"Worker {service_name} not running yet") time.sleep(self.health_check_interval) - continue - # Check container health status - try: - result = subprocess.run( - ["docker", "inspect", "-f", "{{.State.Health.Status}}", container_name], - capture_output=True, - text=True, - check=False - ) - - health_status = result.stdout.strip() - - # If no health check is defined, assume healthy after running - if health_status == "" or health_status == "": - logger.info(f"Worker {service_name} is running (no health check)") - console.print(f"✅ Worker ready: {service_name}") - return True - - if health_status == "healthy": - logger.info(f"Worker {service_name} is healthy") - console.print(f"✅ Worker ready: {service_name}") - return True - - logger.debug(f"Worker {service_name} health: {health_status}") - - except Exception as e: - logger.debug(f"Failed to check health: {e}") - - time.sleep(self.health_check_interval) - - elapsed = time.time() - start_time - logger.warning(f"Worker {service_name} did not become ready within {elapsed:.1f}s") - console.print(f"⚠️ Worker startup timeout after {elapsed:.1f}s", style="yellow") - return False + # Timeout reached + elapsed = int(time.time() - start_time) + logger.warning(f"Worker {service_name} did not become ready within {elapsed}s") + console.print(f"⚠️ Worker startup timeout after {elapsed}s", style="yellow") + console.print(f" Last state: {container_state}, health: {health_status}", style="dim") + return False def stop_worker(self, service_name: str) -> bool: """ @@ -253,6 +534,75 @@ class WorkerManager: console.print(f"❌ Unexpected error: {e}", style="red") return False + def stop_all_workers(self) -> bool: + """ + Stop all running FuzzForge worker containers. + + This uses `docker stop` to stop worker containers individually, + avoiding the Docker Compose profile issue and preventing accidental + shutdown of core services. + + Returns: + True if all workers stopped successfully, False otherwise + """ + try: + console.print("🛑 Stopping all FuzzForge workers...") + + # Get list of all running worker containers + result = subprocess.run( + ["docker", "ps", "--filter", "name=fuzzforge-worker-", "--format", "{{.Names}}"], + capture_output=True, + text=True, + check=False + ) + + running_workers = [name.strip() for name in result.stdout.splitlines() if name.strip()] + + if not running_workers: + console.print("✓ No workers running") + return True + + console.print(f"Found {len(running_workers)} running worker(s):") + for worker in running_workers: + console.print(f" - {worker}") + + # Stop each worker container individually using docker stop + # This is safer than docker compose down and won't affect core services + failed_workers = [] + for worker in running_workers: + try: + logger.info(f"Stopping {worker}...") + result = subprocess.run( + ["docker", "stop", worker], + capture_output=True, + text=True, + check=True, + timeout=30 + ) + console.print(f" ✓ Stopped {worker}") + except subprocess.CalledProcessError as e: + logger.error(f"Failed to stop {worker}: {e.stderr}") + failed_workers.append(worker) + console.print(f" ✗ Failed to stop {worker}", style="red") + except subprocess.TimeoutExpired: + logger.error(f"Timeout stopping {worker}") + failed_workers.append(worker) + console.print(f" ✗ Timeout stopping {worker}", style="red") + + if failed_workers: + console.print(f"\n⚠️ {len(failed_workers)} worker(s) failed to stop", style="yellow") + console.print("💡 Try manually: docker stop " + " ".join(failed_workers), style="dim") + return False + + console.print("\n✅ All workers stopped") + logger.info("All workers stopped successfully") + return True + + except Exception as e: + logger.error(f"Unexpected error stopping workers: {e}") + console.print(f"❌ Unexpected error: {e}", style="red") + return False + def ensure_worker_running( self, worker_info: Dict[str, Any], diff --git a/docker-compose.yml b/docker-compose.yml index 271f7e6..aae0fb5 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -144,6 +144,103 @@ services: networks: - fuzzforge-network + # ============================================================================ + # LLM Proxy - LiteLLM Gateway + # ============================================================================ + llm-proxy: + image: ghcr.io/berriai/litellm:main-stable + container_name: fuzzforge-llm-proxy + depends_on: + llm-proxy-db: + condition: service_healthy + otel-collector: + condition: service_started + env_file: + - ./volumes/env/.env + environment: + PORT: 4000 + DATABASE_URL: postgresql://litellm:litellm@llm-proxy-db:5432/litellm + STORE_MODEL_IN_DB: "True" + UI_USERNAME: ${UI_USERNAME:-fuzzforge} + UI_PASSWORD: ${UI_PASSWORD:-fuzzforge123} + OTEL_EXPORTER_OTLP_ENDPOINT: http://otel-collector:4317 + OTEL_EXPORTER_OTLP_PROTOCOL: grpc + ANTHROPIC_API_KEY: ${LITELLM_ANTHROPIC_API_KEY:-} + OPENAI_API_KEY: ${LITELLM_OPENAI_API_KEY:-} + command: + - "--config" + - "/etc/litellm/proxy_config.yaml" + ports: + - "10999:4000" # Web UI + OpenAI-compatible API + volumes: + - litellm_proxy_data:/var/lib/litellm + - ./volumes/litellm/proxy_config.yaml:/etc/litellm/proxy_config.yaml:ro + networks: + - fuzzforge-network + healthcheck: + test: ["CMD-SHELL", "wget --no-verbose --tries=1 http://localhost:4000/health/liveliness || exit 1"] + interval: 30s + timeout: 10s + retries: 3 + start_period: 40s + restart: unless-stopped + + otel-collector: + image: otel/opentelemetry-collector:latest + container_name: fuzzforge-otel-collector + command: ["--config=/etc/otel-collector/config.yaml"] + volumes: + - ./volumes/otel/collector-config.yaml:/etc/otel-collector/config.yaml:ro + ports: + - "4317:4317" + - "4318:4318" + networks: + - fuzzforge-network + restart: unless-stopped + + llm-proxy-db: + image: postgres:16 + container_name: fuzzforge-llm-proxy-db + environment: + POSTGRES_DB: litellm + POSTGRES_USER: litellm + POSTGRES_PASSWORD: litellm + healthcheck: + test: ["CMD-SHELL", "pg_isready -d litellm -U litellm"] + interval: 5s + timeout: 5s + retries: 12 + volumes: + - litellm_proxy_db:/var/lib/postgresql/data + networks: + - fuzzforge-network + restart: unless-stopped + + # ============================================================================ + # LLM Proxy Bootstrap - Seed providers and virtual keys + # ============================================================================ + llm-proxy-bootstrap: + image: python:3.11-slim + container_name: fuzzforge-llm-proxy-bootstrap + depends_on: + llm-proxy: + condition: service_started + env_file: + - ./volumes/env/.env + environment: + PROXY_BASE_URL: http://llm-proxy:4000 + ENV_FILE_PATH: /bootstrap/env/.env + UI_USERNAME: ${UI_USERNAME:-fuzzforge} + UI_PASSWORD: ${UI_PASSWORD:-fuzzforge123} + volumes: + - ./docker/scripts/bootstrap_llm_proxy.py:/app/bootstrap.py:ro + - ./volumes/env:/bootstrap/env + - litellm_proxy_data:/bootstrap/data + networks: + - fuzzforge-network + command: ["python", "/app/bootstrap.py"] + restart: "no" + # ============================================================================ # Vertical Worker: Rust/Native Security # ============================================================================ @@ -217,9 +314,6 @@ services: context: ./workers/python dockerfile: Dockerfile container_name: fuzzforge-worker-python - profiles: - - workers - - python depends_on: postgresql: condition: service_healthy @@ -345,7 +439,7 @@ services: worker-android: build: context: ./workers/android - dockerfile: Dockerfile + dockerfile: ${ANDROID_DOCKERFILE:-Dockerfile.amd64} container_name: fuzzforge-worker-android profiles: - workers @@ -433,6 +527,9 @@ services: PYTHONPATH: /app PYTHONUNBUFFERED: 1 + # Host filesystem paths (for CLI worker management) + FUZZFORGE_HOST_ROOT: ${PWD} + # Logging LOG_LEVEL: INFO ports: @@ -458,10 +555,11 @@ services: context: ./ai/agents/task_agent dockerfile: Dockerfile container_name: fuzzforge-task-agent + depends_on: + llm-proxy-bootstrap: + condition: service_completed_successfully ports: - "10900:8000" - env_file: - - ./volumes/env/.env environment: - PORT=8000 - PYTHONUNBUFFERED=1 @@ -558,6 +656,10 @@ volumes: name: fuzzforge_worker_ossfuzz_cache worker_ossfuzz_build: name: fuzzforge_worker_ossfuzz_build + litellm_proxy_data: + name: fuzzforge_litellm_proxy_data + litellm_proxy_db: + name: fuzzforge_litellm_proxy_db # Add more worker caches as you add verticals: # worker_web_cache: # worker_ios_cache: @@ -591,6 +693,7 @@ networks: # 4. Web UIs: # - Temporal UI: http://localhost:8233 # - MinIO Console: http://localhost:9001 (user: fuzzforge, pass: fuzzforge123) +# - LiteLLM Proxy: http://localhost:10999 # # 5. Resource Usage (Baseline): # - Temporal: ~500MB diff --git a/docker/scripts/bootstrap_llm_proxy.py b/docker/scripts/bootstrap_llm_proxy.py new file mode 100644 index 0000000..68f6745 --- /dev/null +++ b/docker/scripts/bootstrap_llm_proxy.py @@ -0,0 +1,636 @@ +"""Bootstrap the LiteLLM proxy with provider secrets and default virtual keys. + +The bootstrapper runs as a one-shot container during docker-compose startup. +It performs the following actions: + + 1. Waits for the proxy health endpoint to respond. + 2. Collects upstream provider API keys from the shared .env file (plus any + legacy copies) and mirrors them into a proxy-specific env file + (volumes/env/.env.litellm) so only the proxy container can access them. + 3. Emits a default virtual key for the task agent by calling /key/generate, + persisting the generated token back into volumes/env/.env so the agent can + authenticate through the proxy instead of using raw provider secrets. + 4. Keeps the process idempotent: existing keys are reused and their allowed + model list is refreshed instead of issuing duplicates on every run. +""" + +from __future__ import annotations + +import json +import os +import sys +import time +import urllib.error +import urllib.parse +import urllib.request +from dataclasses import dataclass +from pathlib import Path +from typing import Iterable, Mapping + +PROXY_BASE_URL = os.getenv("PROXY_BASE_URL", "http://llm-proxy:4000").rstrip("/") +ENV_FILE_PATH = Path(os.getenv("ENV_FILE_PATH", "/bootstrap/env/.env")) +LITELLM_ENV_FILE_PATH = Path( + os.getenv("LITELLM_ENV_FILE_PATH", "/bootstrap/env/.env.litellm") +) +LEGACY_ENV_FILE_PATH = Path( + os.getenv("LEGACY_ENV_FILE_PATH", "/bootstrap/env/.env.bifrost") +) +MAX_WAIT_SECONDS = int(os.getenv("LITELLM_PROXY_WAIT_SECONDS", "120")) + + +@dataclass(frozen=True) +class VirtualKeySpec: + """Configuration for a virtual key to be provisioned.""" + env_var: str + alias: str + user_id: str + budget_env_var: str + duration_env_var: str + default_budget: float + default_duration: str + + +# Multiple virtual keys for different services +VIRTUAL_KEYS: tuple[VirtualKeySpec, ...] = ( + VirtualKeySpec( + env_var="OPENAI_API_KEY", + alias="fuzzforge-cli", + user_id="fuzzforge-cli", + budget_env_var="CLI_BUDGET", + duration_env_var="CLI_DURATION", + default_budget=100.0, + default_duration="30d", + ), + VirtualKeySpec( + env_var="TASK_AGENT_API_KEY", + alias="fuzzforge-task-agent", + user_id="fuzzforge-task-agent", + budget_env_var="TASK_AGENT_BUDGET", + duration_env_var="TASK_AGENT_DURATION", + default_budget=25.0, + default_duration="30d", + ), + VirtualKeySpec( + env_var="COGNEE_API_KEY", + alias="fuzzforge-cognee", + user_id="fuzzforge-cognee", + budget_env_var="COGNEE_BUDGET", + duration_env_var="COGNEE_DURATION", + default_budget=50.0, + default_duration="30d", + ), +) + + +@dataclass(frozen=True) +class ProviderSpec: + name: str + litellm_env_var: str + alias_env_var: str + source_env_vars: tuple[str, ...] + + +# Support fresh LiteLLM variables while gracefully migrating legacy env +# aliases on first boot. +PROVIDERS: tuple[ProviderSpec, ...] = ( + ProviderSpec( + "openai", + "OPENAI_API_KEY", + "LITELLM_OPENAI_API_KEY", + ("LITELLM_OPENAI_API_KEY", "BIFROST_OPENAI_KEY"), + ), + ProviderSpec( + "anthropic", + "ANTHROPIC_API_KEY", + "LITELLM_ANTHROPIC_API_KEY", + ("LITELLM_ANTHROPIC_API_KEY", "BIFROST_ANTHROPIC_KEY"), + ), + ProviderSpec( + "gemini", + "GEMINI_API_KEY", + "LITELLM_GEMINI_API_KEY", + ("LITELLM_GEMINI_API_KEY", "BIFROST_GEMINI_KEY"), + ), + ProviderSpec( + "mistral", + "MISTRAL_API_KEY", + "LITELLM_MISTRAL_API_KEY", + ("LITELLM_MISTRAL_API_KEY", "BIFROST_MISTRAL_KEY"), + ), + ProviderSpec( + "openrouter", + "OPENROUTER_API_KEY", + "LITELLM_OPENROUTER_API_KEY", + ("LITELLM_OPENROUTER_API_KEY", "BIFROST_OPENROUTER_KEY"), + ), +) + +PROVIDER_LOOKUP: dict[str, ProviderSpec] = {spec.name: spec for spec in PROVIDERS} + + +def log(message: str) -> None: + print(f"[litellm-bootstrap] {message}", flush=True) + + +def read_lines(path: Path) -> list[str]: + if not path.exists(): + return [] + return path.read_text().splitlines() + + +def write_lines(path: Path, lines: Iterable[str]) -> None: + material = "\n".join(lines) + if material and not material.endswith("\n"): + material += "\n" + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(material) + + +def read_env_file() -> list[str]: + if not ENV_FILE_PATH.exists(): + raise FileNotFoundError( + f"Expected env file at {ENV_FILE_PATH}. Copy volumes/env/.env.template first." + ) + return read_lines(ENV_FILE_PATH) + + +def write_env_file(lines: Iterable[str]) -> None: + write_lines(ENV_FILE_PATH, lines) + + +def read_litellm_env_file() -> list[str]: + return read_lines(LITELLM_ENV_FILE_PATH) + + +def write_litellm_env_file(lines: Iterable[str]) -> None: + write_lines(LITELLM_ENV_FILE_PATH, lines) + + +def read_legacy_env_file() -> Mapping[str, str]: + lines = read_lines(LEGACY_ENV_FILE_PATH) + return parse_env_lines(lines) + + +def set_env_value(lines: list[str], key: str, value: str) -> tuple[list[str], bool]: + prefix = f"{key}=" + new_line = f"{prefix}{value}" + for idx, line in enumerate(lines): + stripped = line.lstrip() + if not stripped or stripped.startswith("#"): + continue + if stripped.startswith(prefix): + if stripped == new_line: + return lines, False + indent = line[: len(line) - len(stripped)] + lines[idx] = f"{indent}{new_line}" + return lines, True + lines.append(new_line) + return lines, True + + +def parse_env_lines(lines: list[str]) -> dict[str, str]: + mapping: dict[str, str] = {} + for raw_line in lines: + stripped = raw_line.strip() + if not stripped or stripped.startswith("#") or "=" not in stripped: + continue + key, value = stripped.split("=", 1) + mapping[key] = value + return mapping + + +def wait_for_proxy() -> None: + health_paths = ("/health/liveliness", "/health", "/") + deadline = time.time() + MAX_WAIT_SECONDS + attempt = 0 + while time.time() < deadline: + attempt += 1 + for path in health_paths: + url = f"{PROXY_BASE_URL}{path}" + try: + with urllib.request.urlopen(url) as response: # noqa: S310 + if response.status < 400: + log(f"Proxy responded on {path} (attempt {attempt})") + return + except urllib.error.URLError as exc: + log(f"Proxy not ready yet ({path}): {exc}") + time.sleep(3) + raise TimeoutError(f"Timed out waiting for proxy at {PROXY_BASE_URL}") + + +def request_json( + path: str, + *, + method: str = "GET", + payload: Mapping[str, object] | None = None, + auth_token: str | None = None, +) -> tuple[int, str]: + url = f"{PROXY_BASE_URL}{path}" + data = None + headers = {"Accept": "application/json"} + if auth_token: + headers["Authorization"] = f"Bearer {auth_token}" + if payload is not None: + data = json.dumps(payload).encode("utf-8") + headers["Content-Type"] = "application/json" + request = urllib.request.Request(url, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(request) as response: # noqa: S310 + body = response.read().decode("utf-8") + return response.status, body + except urllib.error.HTTPError as exc: + body = exc.read().decode("utf-8") + return exc.code, body + + +def get_master_key(env_map: Mapping[str, str]) -> str: + candidate = os.getenv("LITELLM_MASTER_KEY") or env_map.get("LITELLM_MASTER_KEY") + if not candidate: + raise RuntimeError( + "LITELLM_MASTER_KEY is not set. Add it to volumes/env/.env before starting Docker." + ) + value = candidate.strip() + if not value: + raise RuntimeError( + "LITELLM_MASTER_KEY is blank. Provide a non-empty value in the env file." + ) + return value + + +def gather_provider_keys( + env_lines: list[str], + env_map: dict[str, str], + legacy_map: Mapping[str, str], +) -> tuple[dict[str, str], list[str], bool]: + updated_lines = list(env_lines) + discovered: dict[str, str] = {} + changed = False + + for spec in PROVIDERS: + value: str | None = None + for source_var in spec.source_env_vars: + candidate = env_map.get(source_var) or legacy_map.get(source_var) or os.getenv( + source_var + ) + if not candidate: + continue + stripped = candidate.strip() + if stripped: + value = stripped + break + if not value: + continue + + discovered[spec.litellm_env_var] = value + updated_lines, alias_changed = set_env_value( + updated_lines, spec.alias_env_var, value + ) + if alias_changed: + env_map[spec.alias_env_var] = value + changed = True + + return discovered, updated_lines, changed + + +def ensure_litellm_env(provider_values: Mapping[str, str]) -> None: + if not provider_values: + log("No provider secrets discovered; skipping LiteLLM env update") + return + lines = read_litellm_env_file() + updated_lines = list(lines) + changed = False + for env_var, value in provider_values.items(): + updated_lines, var_changed = set_env_value(updated_lines, env_var, value) + if var_changed: + changed = True + if changed or not lines: + write_litellm_env_file(updated_lines) + log(f"Wrote provider secrets to {LITELLM_ENV_FILE_PATH}") + + +def current_env_key(env_map: Mapping[str, str], env_var: str) -> str | None: + candidate = os.getenv(env_var) or env_map.get(env_var) + if not candidate: + return None + value = candidate.strip() + if not value or value.startswith("sk-proxy-"): + return None + return value + + +def collect_default_models(env_map: Mapping[str, str]) -> list[str]: + explicit = ( + os.getenv("LITELLM_DEFAULT_MODELS") + or env_map.get("LITELLM_DEFAULT_MODELS") + or "" + ) + models: list[str] = [] + if explicit: + models.extend( + model.strip() + for model in explicit.split(",") + if model.strip() + ) + if models: + return sorted(dict.fromkeys(models)) + + configured_model = ( + os.getenv("LITELLM_MODEL") or env_map.get("LITELLM_MODEL") or "" + ).strip() + configured_provider = ( + os.getenv("LITELLM_PROVIDER") or env_map.get("LITELLM_PROVIDER") or "" + ).strip() + + if configured_model: + if "/" in configured_model: + models.append(configured_model) + elif configured_provider: + models.append(f"{configured_provider}/{configured_model}") + else: + log( + "LITELLM_MODEL is set without a provider; configure LITELLM_PROVIDER or " + "use the provider/model format (e.g. openai/gpt-4o-mini)." + ) + elif configured_provider: + log( + "LITELLM_PROVIDER configured without a default model. Bootstrap will issue an " + "unrestricted virtual key allowing any proxy-registered model." + ) + + return sorted(dict.fromkeys(models)) + + +def fetch_existing_key_record(master_key: str, key_value: str) -> Mapping[str, object] | None: + encoded = urllib.parse.quote_plus(key_value) + status, body = request_json(f"/key/info?key={encoded}", auth_token=master_key) + if status != 200: + log(f"Key lookup failed ({status}); treating OPENAI_API_KEY as new") + return None + try: + data = json.loads(body) + except json.JSONDecodeError: + log("Key info response was not valid JSON; ignoring") + return None + if isinstance(data, Mapping) and data.get("key"): + return data + return None + + +def fetch_key_by_alias(master_key: str, alias: str) -> str | None: + """Fetch existing key value by alias from LiteLLM proxy.""" + status, body = request_json("/key/info", auth_token=master_key) + if status != 200: + return None + try: + data = json.loads(body) + except json.JSONDecodeError: + return None + if isinstance(data, dict) and "keys" in data: + for key_info in data.get("keys", []): + if isinstance(key_info, dict) and key_info.get("key_alias") == alias: + return str(key_info.get("key", "")).strip() or None + return None + + +def generate_virtual_key( + master_key: str, + models: list[str], + spec: VirtualKeySpec, + env_map: Mapping[str, str], +) -> str: + budget_str = os.getenv(spec.budget_env_var) or env_map.get(spec.budget_env_var) or str(spec.default_budget) + try: + budget = float(budget_str) + except ValueError: + budget = spec.default_budget + + duration = os.getenv(spec.duration_env_var) or env_map.get(spec.duration_env_var) or spec.default_duration + + payload: dict[str, object] = { + "key_alias": spec.alias, + "user_id": spec.user_id, + "duration": duration, + "max_budget": budget, + "metadata": { + "provisioned_by": "bootstrap", + "service": spec.alias, + "default_models": models, + }, + "key_type": "llm_api", + } + if models: + payload["models"] = models + status, body = request_json( + "/key/generate", method="POST", payload=payload, auth_token=master_key + ) + if status == 400 and "already exists" in body.lower(): + # Key alias already exists but .env is out of sync (e.g., after docker prune) + # Delete the old key and regenerate + log(f"Key alias '{spec.alias}' already exists in database but not in .env; deleting and regenerating") + # Try to delete by alias using POST /key/delete with key_aliases array + delete_payload = {"key_aliases": [spec.alias]} + delete_status, delete_body = request_json( + "/key/delete", method="POST", payload=delete_payload, auth_token=master_key + ) + if delete_status not in {200, 201}: + log(f"Warning: Could not delete existing key alias {spec.alias} ({delete_status}): {delete_body}") + # Continue anyway and try to generate + else: + log(f"Deleted existing key alias {spec.alias}") + + # Retry generation + status, body = request_json( + "/key/generate", method="POST", payload=payload, auth_token=master_key + ) + if status not in {200, 201}: + raise RuntimeError(f"Failed to generate virtual key for {spec.alias} ({status}): {body}") + try: + data = json.loads(body) + except json.JSONDecodeError as exc: + raise RuntimeError(f"Virtual key response for {spec.alias} was not valid JSON") from exc + if isinstance(data, Mapping): + key_value = str(data.get("key") or data.get("token") or "").strip() + if key_value: + log(f"Generated new LiteLLM virtual key for {spec.alias} (budget: ${budget}, duration: {duration})") + return key_value + raise RuntimeError(f"Virtual key response for {spec.alias} did not include a key field") + + +def update_virtual_key( + master_key: str, + key_value: str, + models: list[str], + spec: VirtualKeySpec, +) -> None: + if not models: + return + payload: dict[str, object] = { + "key": key_value, + "models": models, + } + status, body = request_json( + "/key/update", method="POST", payload=payload, auth_token=master_key + ) + if status != 200: + log(f"Virtual key update for {spec.alias} skipped ({status}): {body}") + else: + log(f"Refreshed allowed models for {spec.alias}") + + +def persist_key_to_env(new_key: str, env_var: str) -> None: + lines = read_env_file() + updated_lines, changed = set_env_value(lines, env_var, new_key) + # Always update the environment variable, even if file wasn't changed + os.environ[env_var] = new_key + if changed: + write_env_file(updated_lines) + log(f"Persisted {env_var} to {ENV_FILE_PATH}") + else: + log(f"{env_var} already up-to-date in env file") + + +def ensure_virtual_key( + master_key: str, + models: list[str], + env_map: Mapping[str, str], + spec: VirtualKeySpec, +) -> str: + allowed_models: list[str] = [] + sync_flag = os.getenv("LITELLM_SYNC_VIRTUAL_KEY_MODELS", "").strip().lower() + if models and (sync_flag in {"1", "true", "yes", "on"} or models == ["*"]): + allowed_models = models + existing_key = current_env_key(env_map, spec.env_var) + if existing_key: + record = fetch_existing_key_record(master_key, existing_key) + if record: + log(f"Reusing existing LiteLLM virtual key for {spec.alias}") + if allowed_models: + update_virtual_key(master_key, existing_key, allowed_models, spec) + return existing_key + log(f"Existing {spec.env_var} not registered with proxy; generating new key") + + new_key = generate_virtual_key(master_key, models, spec, env_map) + if allowed_models: + update_virtual_key(master_key, new_key, allowed_models, spec) + return new_key + + +def _split_model_identifier(model: str) -> tuple[str | None, str]: + if "/" in model: + provider, short_name = model.split("/", 1) + return provider.lower().strip() or None, short_name.strip() + return None, model.strip() + + +def ensure_models_registered( + master_key: str, + models: list[str], + env_map: Mapping[str, str], +) -> None: + if not models: + return + for model in models: + provider, short_name = _split_model_identifier(model) + if not provider or not short_name: + log(f"Skipping model '{model}' (no provider segment)") + continue + spec = PROVIDER_LOOKUP.get(provider) + if not spec: + log(f"No provider spec registered for '{provider}'; skipping model '{model}'") + continue + provider_secret = ( + env_map.get(spec.alias_env_var) + or env_map.get(spec.litellm_env_var) + or os.getenv(spec.alias_env_var) + or os.getenv(spec.litellm_env_var) + ) + if not provider_secret: + log( + f"Provider secret for '{provider}' not found; skipping model registration" + ) + continue + + api_key_reference = f"os.environ/{spec.alias_env_var}" + payload: dict[str, object] = { + "model_name": model, + "litellm_params": { + "model": short_name, + "custom_llm_provider": provider, + "api_key": api_key_reference, + }, + "model_info": { + "provider": provider, + "description": "Auto-registered during bootstrap", + }, + } + + status, body = request_json( + "/model/new", method="POST", payload=payload, auth_token=master_key + ) + if status in {200, 201}: + log(f"Registered LiteLLM model '{model}'") + continue + try: + data = json.loads(body) + except json.JSONDecodeError: + data = body + error_message = ( + data.get("error") if isinstance(data, Mapping) else str(data) + ) + if status == 409 or ( + isinstance(error_message, str) + and "already" in error_message.lower() + ): + log(f"Model '{model}' already present; skipping") + continue + log(f"Failed to register model '{model}' ({status}): {error_message}") + + +def main() -> int: + log("Bootstrapping LiteLLM proxy") + try: + wait_for_proxy() + env_lines = read_env_file() + env_map = parse_env_lines(env_lines) + legacy_map = read_legacy_env_file() + master_key = get_master_key(env_map) + + provider_values, updated_env_lines, env_changed = gather_provider_keys( + env_lines, env_map, legacy_map + ) + if env_changed: + write_env_file(updated_env_lines) + env_map = parse_env_lines(updated_env_lines) + log("Updated LiteLLM provider aliases in shared env file") + + ensure_litellm_env(provider_values) + + models = collect_default_models(env_map) + if models: + log("Default models for virtual keys: %s" % ", ".join(models)) + models_for_key = models + else: + log( + "No default models configured; provisioning virtual keys without model " + "restrictions (model-agnostic)." + ) + models_for_key = ["*"] + + # Generate virtual keys for each service + for spec in VIRTUAL_KEYS: + virtual_key = ensure_virtual_key(master_key, models_for_key, env_map, spec) + persist_key_to_env(virtual_key, spec.env_var) + + # Register models if any were specified + if models: + ensure_models_registered(master_key, models, env_map) + + log("Bootstrap complete") + return 0 + except Exception as exc: # pragma: no cover - startup failure reported to logs + log(f"Bootstrap failed: {exc}") + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/docs/blog/2025-01-16-v0.7.0-temporal-workers-release.md b/docs/blog/2025-01-16-v0.7.0-temporal-workers-release.md index ef8a641..329ca7a 100644 --- a/docs/blog/2025-01-16-v0.7.0-temporal-workers-release.md +++ b/docs/blog/2025-01-16-v0.7.0-temporal-workers-release.md @@ -225,7 +225,7 @@ docker compose up -d # All workers start Set up AI workflows with API keys: ```bash -cp volumes/env/.env.example volumes/env/.env +cp volumes/env/.env.template volumes/env/.env # Edit .env and add your API keys (OpenAI, Anthropic, etc.) ``` diff --git a/docs/docs/how-to/docker-setup.md b/docs/docs/how-to/docker-setup.md index 39c0de9..f4c2fa0 100644 --- a/docs/docs/how-to/docker-setup.md +++ b/docs/docs/how-to/docker-setup.md @@ -110,7 +110,32 @@ fuzzforge workflow run secret_detection ./codebase ### Manual Worker Management -Start specific workers when needed: +**Quick Reference - Workflow to Worker Mapping:** + +| Workflow | Worker Service | Docker Command | +|----------|----------------|----------------| +| `security_assessment`, `python_sast`, `llm_analysis`, `atheris_fuzzing` | worker-python | `docker compose up -d worker-python` | +| `android_static_analysis` | worker-android | `docker compose up -d worker-android` | +| `cargo_fuzzing` | worker-rust | `docker compose up -d worker-rust` | +| `ossfuzz_campaign` | worker-ossfuzz | `docker compose up -d worker-ossfuzz` | +| `llm_secret_detection`, `trufflehog_detection`, `gitleaks_detection` | worker-secrets | `docker compose up -d worker-secrets` | + +FuzzForge CLI provides convenient commands for managing workers: + +```bash +# List all workers and their status +ff worker list +ff worker list --all # Include stopped workers + +# Start a specific worker +ff worker start python +ff worker start android --build # Rebuild before starting + +# Stop all workers +ff worker stop +``` + +You can also use Docker commands directly: ```bash # Start a single worker @@ -123,6 +148,33 @@ docker compose --profile workers up -d docker stop fuzzforge-worker-ossfuzz ``` +### Stopping Workers Properly + +The easiest way to stop workers is using the CLI: + +```bash +# Stop all running workers (recommended) +ff worker stop +``` + +This command safely stops all worker containers without affecting core services. + +Alternatively, you can use Docker commands: + +```bash +# Stop individual worker +docker stop fuzzforge-worker-python + +# Stop all workers using docker compose +# Note: This requires the --profile flag because workers are in profiles +docker compose down --profile workers +``` + +**Important:** Workers use Docker Compose profiles to prevent auto-starting. When using Docker commands directly: +- `docker compose down` (without `--profile workers`) does NOT stop workers +- Workers remain running unless explicitly stopped with the profile flag or `docker stop` +- Use `ff worker stop` for the safest option that won't affect core services + ### Resource Comparison | Command | Workers Started | RAM Usage | @@ -171,7 +223,7 @@ FuzzForge requires `volumes/env/.env` to start. This file contains API keys and ```bash # Copy the example file -cp volumes/env/.env.example volumes/env/.env +cp volumes/env/.env.template volumes/env/.env # Edit to add your API keys (if using AI features) nano volumes/env/.env diff --git a/docs/docs/how-to/litellm-hot-swap.md b/docs/docs/how-to/litellm-hot-swap.md new file mode 100644 index 0000000..8c1d138 --- /dev/null +++ b/docs/docs/how-to/litellm-hot-swap.md @@ -0,0 +1,179 @@ +--- +title: "Hot-Swap LiteLLM Models" +description: "Register OpenAI and Anthropic models with the bundled LiteLLM proxy and switch them on the task agent without downtime." +--- + +LiteLLM sits between the task agent and upstream providers, so every model change +is just an API call. This guide walks through registering OpenAI and Anthropic +models, updating the virtual key, and exercising the A2A hot-swap flow. + +## Prerequisites + +- `docker compose up llm-proxy llm-proxy-db task-agent` +- Provider secrets in `volumes/env/.env`: + - `LITELLM_OPENAI_API_KEY` + - `LITELLM_ANTHROPIC_API_KEY` +- Master key (`LITELLM_MASTER_KEY`) and task-agent virtual key (auto-generated + during bootstrap) + +> UI access uses `UI_USERNAME` / `UI_PASSWORD` (defaults: `fuzzforge` / +> `fuzzforge123`). Change them by exporting new values before running compose. + +## Register Provider Models + +Use the admin API to register the models the proxy should expose. The snippet +below creates aliases for OpenAI `gpt-5`, `gpt-5-mini`, and Anthropic +`claude-sonnet-4-5`. + +```bash +MASTER_KEY=$(awk -F= '$1=="LITELLM_MASTER_KEY"{print $2}' volumes/env/.env) +export OPENAI_API_KEY=$(awk -F= '$1=="OPENAI_API_KEY"{print $2}' volumes/env/.env) +python - <<'PY' +import os, requests +master = os.environ['MASTER_KEY'].strip() +base = 'http://localhost:10999' +models = [ + { + "model_name": "openai/gpt-5", + "litellm_params": { + "model": "gpt-5", + "custom_llm_provider": "openai", + "api_key": "os.environ/LITELLM_OPENAI_API_KEY" + }, + "model_info": { + "provider": "openai", + "description": "OpenAI GPT-5" + } + }, + { + "model_name": "openai/gpt-5-mini", + "litellm_params": { + "model": "gpt-5-mini", + "custom_llm_provider": "openai", + "api_key": "os.environ/LITELLM_OPENAI_API_KEY" + }, + "model_info": { + "provider": "openai", + "description": "OpenAI GPT-5 mini" + } + }, + { + "model_name": "anthropic/claude-sonnet-4-5", + "litellm_params": { + "model": "claude-sonnet-4-5", + "custom_llm_provider": "anthropic", + "api_key": "os.environ/LITELLM_ANTHROPIC_API_KEY" + }, + "model_info": { + "provider": "anthropic", + "description": "Anthropic Claude Sonnet 4.5" + } + } +] +for payload in models: + resp = requests.post( + f"{base}/model/new", + headers={"Authorization": f"Bearer {master}", "Content-Type": "application/json"}, + json=payload, + timeout=60, + ) + if resp.status_code not in (200, 201, 409): + raise SystemExit(f"Failed to register {payload['model_name']}: {resp.status_code} {resp.text}") + print(payload['model_name'], '=>', resp.status_code) +PY +``` + +Each entry stores the upstream secret by reference (`os.environ/...`) so the +raw API key never leaves the container environment. + +## Relax Virtual Key Model Restrictions + +Let the agent key call every model on the proxy: + +```bash +MASTER_KEY=$(awk -F= '$1=="LITELLM_MASTER_KEY"{print $2}' volumes/env/.env) +VK=$(awk -F= '$1=="OPENAI_API_KEY"{print $2}' volumes/env/.env) +python - <<'PY' +import os, requests, json +resp = requests.post( + 'http://localhost:10999/key/update', + headers={ + 'Authorization': f"Bearer {os.environ['MASTER_KEY'].strip()}", + 'Content-Type': 'application/json' + }, + json={'key': os.environ['VK'].strip(), 'models': []}, + timeout=60, +) +print(json.dumps(resp.json(), indent=2)) +PY +``` + +Restart the task agent so it sees the refreshed key: + +```bash +docker compose restart task-agent +``` + +## Hot-Swap With The A2A Helper + +Switch models without restarting the service: + +```bash +# Ensure the CLI reads the latest virtual key +export OPENAI_API_KEY=$(awk -F= '$1=="OPENAI_API_KEY"{print $2}' volumes/env/.env) + +# OpenAI gpt-5 alias +python ai/agents/task_agent/a2a_hot_swap.py \ + --url http://localhost:10900/a2a/litellm_agent \ + --model openai gpt-5 \ + --context switch-demo + +# Confirm the response comes from the new model +python ai/agents/task_agent/a2a_hot_swap.py \ + --url http://localhost:10900/a2a/litellm_agent \ + --message "Which model am I using?" \ + --context switch-demo + +# Swap to gpt-5-mini +python ai/agents/task_agent/a2a_hot_swap.py --url http://localhost:10900/a2a/litellm_agent --model openai gpt-5-mini --context switch-demo + +# Swap to Anthropic Claude Sonnet 4.5 +python ai/agents/task_agent/a2a_hot_swap.py --url http://localhost:10900/a2a/litellm_agent --model anthropic claude-sonnet-4-5 --context switch-demo +``` + +> Each invocation reuses the same conversation context (`switch-demo`) so you +> can confirm the active provider by asking follow-up questions. + +## Resetting The Proxy (Optional) + +To wipe the LiteLLM state and rerun bootstrap: + +```bash +docker compose down llm-proxy llm-proxy-db llm-proxy-bootstrap + +docker volume rm fuzzforge_litellm_proxy_data fuzzforge_litellm_proxy_db + +docker compose up -d llm-proxy-db llm-proxy +``` + +After the proxy is healthy, rerun the registration script and key update. The +bootstrap container mirrors secrets into `.env.litellm` and reissues the task +agent key automatically. + +## How The Pieces Fit Together + +1. **LiteLLM Proxy** exposes OpenAI-compatible routes and stores provider + metadata in Postgres. +2. **Bootstrap Container** waits for `/health/liveliness`, mirrors secrets into + `.env.litellm`, registers any models you script, and keeps the virtual key in + sync with the discovered model list. +3. **Task Agent** calls the proxy via `FF_LLM_PROXY_BASE_URL`. The hot-swap tool + updates the agent’s runtime configuration, so switching providers is just a + control message. +4. **Virtual Keys** carry quotas and allowed models. Setting the `models` array + to `[]` lets the key use anything registered on the proxy. + +Keep the master key and generated virtual keys somewhere safe—they grant full +admin and agent access respectively. When you add a new provider (e.g., Ollama) +just register the model via `/model/new`, update the key if needed, and repeat +the hot-swap steps. diff --git a/docs/docs/how-to/llm-proxy.md b/docs/docs/how-to/llm-proxy.md new file mode 100644 index 0000000..4d6a0db --- /dev/null +++ b/docs/docs/how-to/llm-proxy.md @@ -0,0 +1,194 @@ +--- +title: "Run the LLM Proxy" +description: "Run the LiteLLM gateway that ships with FuzzForge and connect it to the task agent." +--- + +## Overview + +FuzzForge routes every LLM request through a LiteLLM proxy so that usage can be +metered, priced, and rate limited per user. Docker Compose starts the proxy in a +hardened container, while a bootstrap job seeds upstream provider secrets and +issues a virtual key for the task agent automatically. + +LiteLLM exposes the OpenAI-compatible APIs (`/v1/*`) plus a rich admin UI. All +traffic stays on your network and upstream credentials never leave the proxy +container. + +## Before You Start + +1. Copy `volumes/env/.env.template` to `volumes/env/.env` and set the basics: + - `LITELLM_MASTER_KEY` — admin token used to manage the proxy + - `LITELLM_SALT_KEY` — random string used to encrypt provider credentials + - Provider secrets under `LITELLM__API_KEY` (for example + `LITELLM_OPENAI_API_KEY`) + - Leave `OPENAI_API_KEY=sk-proxy-default`; the bootstrap job replaces it with a + LiteLLM-issued virtual key +2. When running tools outside Docker, change `FF_LLM_PROXY_BASE_URL` to the + published host port (`http://localhost:10999`). Inside Docker the default + value `http://llm-proxy:4000` already resolves to the container. + +## Start the Proxy + +```bash +docker compose up llm-proxy +``` + +The service publishes two things: + +- HTTP API + admin UI on `http://localhost:10999` +- Persistent SQLite state inside the named volume + `fuzzforge_litellm_proxy_data` + +The UI login uses the `UI_USERNAME` / `UI_PASSWORD` pair (defaults to +`fuzzforge` / `fuzzforge123`). To change them, set the environment variables +before you run `docker compose up`: + +```bash +export UI_USERNAME=myadmin +export UI_PASSWORD=super-secret +docker compose up llm-proxy +``` + +You can also edit the values directly in `docker-compose.yml` if you prefer to +check them into a different secrets manager. + +Proxy-wide settings now live in `volumes/litellm/proxy_config.yaml`. By +default it enables `store_model_in_db` and `store_prompts_in_spend_logs`, which +lets the UI display request/response payloads for new calls. Update this file +if you need additional LiteLLM options and restart the `llm-proxy` container. + +LiteLLM's health endpoint lives at `/health/liveliness`. You can verify it from +another terminal: + +```bash +curl http://localhost:10999/health/liveliness +``` + +## What the Bootstrapper Does + +During startup the `llm-proxy-bootstrap` container performs three actions: + +1. **Wait for the proxy** — Blocks until `/health/liveliness` becomes healthy. +2. **Mirror provider secrets** — Reads `volumes/env/.env` and writes any + `LITELLM_*_API_KEY` values into `volumes/env/.env.litellm`. The file is + created automatically on first boot; if you delete it, bootstrap will + recreate it and the proxy continues to read secrets from `.env`. +3. **Issue the default virtual key** — Calls `/key/generate` with the master key + and persists the generated token back into `volumes/env/.env` (replacing the + `sk-proxy-default` placeholder). The key is scoped to + `LITELLM_DEFAULT_MODELS` when that variable is set; otherwise it uses the + model from `LITELLM_MODEL`. + +The sequence is idempotent. Existing provider secrets and virtual keys are +reused on subsequent runs, and the allowed-model list is refreshed via +`/key/update` if you change the defaults. + +## Managing Virtual Keys + +LiteLLM keys act as per-user credentials. The default key, named +`task-agent default`, is created automatically for the task agent. You can issue +more keys for teammates or CI jobs with the same management API: + +```bash +curl http://localhost:10999/key/generate \ + -H "Authorization: Bearer $LITELLM_MASTER_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "key_alias": "demo-user", + "user_id": "demo", + "models": ["openai/gpt-4o-mini"], + "duration": "30d", + "max_budget": 50, + "metadata": {"team": "sandbox"} + }' +``` + +Use `/key/update` to adjust budgets or the allowed-model list on existing keys: + +```bash +curl http://localhost:10999/key/update \ + -H "Authorization: Bearer $LITELLM_MASTER_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "key": "sk-...", + "models": ["openai/*", "anthropic/*"], + "max_budget": 100 + }' +``` + +The admin UI (navigate to `http://localhost:10999/ui`) provides equivalent +controls for creating keys, routing models, auditing spend, and exporting logs. + +## Wiring the Task Agent + +The task agent already expects to talk to the proxy. Confirm these values in +`volumes/env/.env` before launching the stack: + +```bash +FF_LLM_PROXY_BASE_URL=http://llm-proxy:4000 # or http://localhost:10999 when outside Docker +OPENAI_API_KEY= +LITELLM_MODEL=openai/gpt-5 +LITELLM_PROVIDER=openai +``` + +Restart the agent container after changing environment variables so the process +picks up the updates. + +To validate the integration end to end, call the proxy directly: + +```bash +curl -X POST http://localhost:10999/v1/chat/completions \ + -H "Authorization: Bearer $OPENAI_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "model": "openai/gpt-4o-mini", + "messages": [{"role": "user", "content": "Proxy health check"}] + }' +``` + +A JSON response indicates the proxy can reach your upstream provider using the +mirrored secrets. + +## Local Runtimes (Ollama, etc.) + +LiteLLM supports non-hosted providers as well. To route requests to a local +runtime such as Ollama: + +1. Set the appropriate provider key in the env file + (for Ollama, point LiteLLM at `OLLAMA_API_BASE` inside the container). +2. Add the passthrough model either from the UI (**Models → Add Model**) or + by calling `/model/new` with the master key. +3. Update `LITELLM_DEFAULT_MODELS` (and regenerate the virtual key if you want +the default key to include it). + +The task agent keeps using the same OpenAI-compatible surface while LiteLLM +handles the translation to your runtime. + +## Next Steps + +- Explore [LiteLLM's documentation](https://docs.litellm.ai/docs/simple_proxy) + for advanced routing, cost controls, and observability hooks. +- Configure Slack/Prometheus integrations from the UI to monitor usage. +- Rotate the master key periodically and store it in your secrets manager, as it + grants full admin access to the proxy. + +## Observability + +LiteLLM ships with OpenTelemetry hooks for traces and metrics. This repository +already includes an OTLP collector (`otel-collector` service) and mounts a +default configuration that forwards traces to standard output. To wire it up: + +1. Edit `volumes/otel/collector-config.yaml` if you want to forward to Jaeger, + Datadog, etc. The initial config uses the logging exporter so you can see + spans immediately via `docker compose logs -f otel-collector`. +2. Customize `volumes/litellm/proxy_config.yaml` if you need additional + callbacks; `general_settings.otel: true` and `litellm_settings.callbacks: + ["otel"]` are already present so no extra code changes are required. +3. (Optional) Override `OTEL_EXPORTER_OTLP_*` environment variables in + `docker-compose.yml` or your shell to point at a remote collector. + +After updating the configs, run `docker compose up -d otel-collector llm-proxy` +and generate a request (for example, trigger `ff workflow run llm_analysis`). +New traces will show up in the collector logs or whichever backend you +configured. See the official LiteLLM guide for advanced exporter options: +https://docs.litellm.ai/docs/observability/opentelemetry_integration. diff --git a/docs/docs/how-to/troubleshooting.md b/docs/docs/how-to/troubleshooting.md index 8784ef3..38165ae 100644 --- a/docs/docs/how-to/troubleshooting.md +++ b/docs/docs/how-to/troubleshooting.md @@ -33,7 +33,7 @@ The required `volumes/env/.env` file is missing. Docker Compose needs this file **How to fix:** ```bash # Create the environment file from the template -cp volumes/env/.env.example volumes/env/.env +cp volumes/env/.env.template volumes/env/.env # Restart Docker Compose docker compose -f docker-compose.yml down @@ -106,6 +106,46 @@ File upload to MinIO failed or worker can't download target. ``` - Reduce the number of concurrent workflows if your system is resource-constrained. +### Workflow requires worker not running + +**What's happening?** +You see a warning message like: +``` +⚠️ Could not check worker requirements: Cannot find docker-compose.yml. + Ensure backend is running, run from FuzzForge directory, or set + FUZZFORGE_ROOT environment variable. + Continuing without worker management... +``` + +Or the workflow fails to start because the required worker isn't running. + +**How to fix:** +Start the worker required for your workflow before running it: + +| Workflow | Worker Required | Startup Command | +|----------|----------------|-----------------| +| `android_static_analysis` | worker-android | `docker compose up -d worker-android` | +| `security_assessment` | worker-python | `docker compose up -d worker-python` | +| `python_sast` | worker-python | `docker compose up -d worker-python` | +| `llm_analysis` | worker-python | `docker compose up -d worker-python` | +| `atheris_fuzzing` | worker-python | `docker compose up -d worker-python` | +| `ossfuzz_campaign` | worker-ossfuzz | `docker compose up -d worker-ossfuzz` | +| `cargo_fuzzing` | worker-rust | `docker compose up -d worker-rust` | +| `llm_secret_detection` | worker-secrets | `docker compose up -d worker-secrets` | +| `trufflehog_detection` | worker-secrets | `docker compose up -d worker-secrets` | +| `gitleaks_detection` | worker-secrets | `docker compose up -d worker-secrets` | + +**Check worker status:** +```bash +# Check if a specific worker is running +docker compose ps worker-android + +# Check all workers +docker compose ps | grep worker +``` + +**Note:** Workers don't auto-start by default to save system resources. For more details on worker management, see the [Docker Setup guide](docker-setup.md#worker-management). + --- ## Service Connectivity Issues diff --git a/docs/docs/reference/cli-reference.md b/docs/docs/reference/cli-reference.md new file mode 100644 index 0000000..dd7b4d2 --- /dev/null +++ b/docs/docs/reference/cli-reference.md @@ -0,0 +1,616 @@ +# FuzzForge CLI Reference + +Complete reference for the FuzzForge CLI (`ff` command). Use this as your quick lookup for all commands, options, and examples. + +--- + +## Global Options + +| Option | Description | +|--------|-------------| +| `--help`, `-h` | Show help message | +| `--version`, `-v` | Show version information | + +--- + +## Core Commands + +### `ff init` + +Initialize a new FuzzForge project in the current directory. + +**Usage:** +```bash +ff init [OPTIONS] +``` + +**Options:** +- `--name`, `-n` — Project name (defaults to current directory name) +- `--api-url`, `-u` — FuzzForge API URL (defaults to http://localhost:8000) +- `--force`, `-f` — Force initialization even if project already exists + +**Examples:** +```bash +ff init # Initialize with defaults +ff init --name my-project # Set custom project name +ff init --api-url http://prod:8000 # Use custom API URL +``` + +--- + +### `ff status` + +Show project and latest execution status. + +**Usage:** +```bash +ff status +``` + +**Example Output:** +``` +📊 Project Status + Project: my-security-project + API URL: http://localhost:8000 + +Latest Execution: + Run ID: security_scan-a1b2c3 + Workflow: security_assessment + Status: COMPLETED + Started: 2 hours ago +``` + +--- + +### `ff config` + +Manage project configuration. + +**Usage:** +```bash +ff config # Show all config +ff config # Get specific value +ff config # Set value +``` + +**Examples:** +```bash +ff config # Display all settings +ff config api_url # Get API URL +ff config api_url http://prod:8000 # Set API URL +``` + +--- + +### `ff clean` + +Clean old execution data and findings. + +**Usage:** +```bash +ff clean [OPTIONS] +``` + +**Options:** +- `--days`, `-d` — Remove data older than this many days (default: 90) +- `--dry-run` — Show what would be deleted without deleting + +**Examples:** +```bash +ff clean # Clean data older than 90 days +ff clean --days 30 # Clean data older than 30 days +ff clean --dry-run # Preview what would be deleted +``` + +--- + +## Workflow Commands + +### `ff workflows` + +Browse and list available workflows. + +**Usage:** +```bash +ff workflows [COMMAND] +``` + +**Subcommands:** +- `list` — List all available workflows +- `info ` — Show detailed workflow information +- `params ` — Show workflow parameters + +**Examples:** +```bash +ff workflows list # List all workflows +ff workflows info python_sast # Show workflow details +ff workflows params python_sast # Show parameters +``` + +--- + +### `ff workflow` + +Execute and manage individual workflows. + +**Usage:** +```bash +ff workflow +``` + +**Subcommands:** + +#### `ff workflow run` + +Execute a security testing workflow. + +**Usage:** +```bash +ff workflow run [params...] [OPTIONS] +``` + +**Arguments:** +- `` — Workflow name +- `` — Target path to analyze +- `[params...]` — Parameters as `key=value` pairs + +**Options:** +- `--param-file`, `-f` — JSON file containing workflow parameters +- `--timeout`, `-t` — Execution timeout in seconds +- `--interactive` / `--no-interactive`, `-i` / `-n` — Interactive parameter input (default: interactive) +- `--wait`, `-w` — Wait for execution to complete +- `--live`, `-l` — Start live monitoring after execution +- `--auto-start` / `--no-auto-start` — Automatically start required worker +- `--auto-stop` / `--no-auto-stop` — Automatically stop worker after completion +- `--fail-on` — Fail build if findings match SARIF level (error, warning, note, info, all, none) +- `--export-sarif` — Export SARIF results to file after completion + +**Examples:** +```bash +# Basic workflow execution +ff workflow run python_sast ./project + +# With parameters +ff workflow run python_sast ./project check_secrets=true + +# CI/CD integration - fail on errors +ff workflow run python_sast ./project --wait --no-interactive \ + --fail-on error --export-sarif results.sarif + +# With parameter file +ff workflow run python_sast ./project --param-file config.json + +# Live monitoring for fuzzing +ff workflow run atheris_fuzzing ./project --live +``` + +#### `ff workflow status` + +Check status of latest or specific workflow execution. + +**Usage:** +```bash +ff workflow status [run_id] +``` + +**Examples:** +```bash +ff workflow status # Show latest execution status +ff workflow status python_sast-abc123 # Show specific execution +``` + +#### `ff workflow history` + +Show execution history. + +**Usage:** +```bash +ff workflow history [OPTIONS] +``` + +**Options:** +- `--limit`, `-l` — Number of executions to show (default: 10) + +**Example:** +```bash +ff workflow history --limit 20 +``` + +#### `ff workflow retry` + +Retry a failed workflow execution. + +**Usage:** +```bash +ff workflow retry +``` + +**Example:** +```bash +ff workflow retry python_sast-abc123 +``` + +--- + +## Finding Commands + +### `ff findings` + +Browse all findings across executions. + +**Usage:** +```bash +ff findings [COMMAND] +``` + +**Subcommands:** + +#### `ff findings list` + +List findings from a specific run. + +**Usage:** +```bash +ff findings list [run_id] [OPTIONS] +``` + +**Options:** +- `--format` — Output format: table, json, sarif (default: table) +- `--save` — Save findings to file + +**Examples:** +```bash +ff findings list # Show latest findings +ff findings list python_sast-abc123 # Show specific run +ff findings list --format json # JSON output +ff findings list --format sarif --save # Export SARIF +``` + +#### `ff findings export` + +Export findings to various formats. + +**Usage:** +```bash +ff findings export [OPTIONS] +``` + +**Options:** +- `--format` — Output format: json, sarif, csv +- `--output`, `-o` — Output file path + +**Example:** +```bash +ff findings export python_sast-abc123 --format sarif --output results.sarif +``` + +#### `ff findings history` + +Show finding history across multiple runs. + +**Usage:** +```bash +ff findings history [OPTIONS] +``` + +**Options:** +- `--limit`, `-l` — Number of runs to include (default: 10) + +--- + +### `ff finding` + +View and analyze individual findings. + +**Usage:** +```bash +ff finding [id] # Show latest or specific finding +ff finding show --rule # Show specific finding detail +``` + +**Examples:** +```bash +ff finding # Show latest finding +ff finding python_sast-abc123 # Show specific run findings +ff finding show python_sast-abc123 --rule f2cf5e3e # Show specific finding +``` + +--- + +## Worker Management Commands + +### `ff worker` + +Manage Temporal workers for workflow execution. + +**Usage:** +```bash +ff worker +``` + +**Subcommands:** + +#### `ff worker list` + +List FuzzForge workers and their status. + +**Usage:** +```bash +ff worker list [OPTIONS] +``` + +**Options:** +- `--all`, `-a` — Show all workers (including stopped) + +**Examples:** +```bash +ff worker list # Show running workers +ff worker list --all # Show all workers +``` + +**Example Output:** +``` +FuzzForge Workers +┏━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┓ +┃ Worker ┃ Status ┃ Uptime ┃ +┡━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━┩ +│ android │ ● Running │ 5 minutes ago │ +│ python │ ● Running │ 10 minutes ago │ +└─────────┴───────────┴────────────────┘ + +✅ 2 worker(s) running +``` + +#### `ff worker start` + +Start a specific worker. + +**Usage:** +```bash +ff worker start [OPTIONS] +``` + +**Arguments:** +- `` — Worker name (e.g., python, android, rust, secrets) + +**Options:** +- `--build` — Rebuild worker image before starting + +**Examples:** +```bash +ff worker start python # Start Python worker +ff worker start android --build # Rebuild and start Android worker +``` + +**Available Workers:** +- `python` — Python security analysis and fuzzing +- `android` — Android APK analysis +- `rust` — Rust fuzzing and analysis +- `secrets` — Secret detection workflows +- `ossfuzz` — OSS-Fuzz integration + +#### `ff worker stop` + +Stop all running FuzzForge workers. + +**Usage:** +```bash +ff worker stop [OPTIONS] +``` + +**Options:** +- `--all` — Stop all workers (default behavior, flag for clarity) + +**Example:** +```bash +ff worker stop +``` + +**Note:** This command stops only worker containers, leaving core services (backend, temporal, minio) running. + +--- + +## Monitoring Commands + +### `ff monitor` + +Real-time monitoring for running workflows. + +**Usage:** +```bash +ff monitor [COMMAND] +``` + +**Subcommands:** +- `live ` — Live monitoring for a specific execution +- `stats ` — Show statistics for fuzzing workflows + +**Examples:** +```bash +ff monitor live atheris-abc123 # Monitor fuzzing campaign +ff monitor stats atheris-abc123 # Show fuzzing statistics +``` + +--- + +## AI Integration Commands + +### `ff ai` + +AI-powered analysis and assistance. + +**Usage:** +```bash +ff ai [COMMAND] +``` + +**Subcommands:** +- `analyze ` — Analyze findings with AI +- `explain ` — Get AI explanation of a finding +- `remediate ` — Get remediation suggestions + +**Examples:** +```bash +ff ai analyze python_sast-abc123 # Analyze all findings +ff ai explain python_sast-abc123:finding1 # Explain specific finding +ff ai remediate python_sast-abc123:finding1 # Get fix suggestions +``` + +--- + +## Knowledge Ingestion Commands + +### `ff ingest` + +Ingest knowledge into the AI knowledge base. + +**Usage:** +```bash +ff ingest [COMMAND] +``` + +**Subcommands:** +- `file ` — Ingest a file +- `directory ` — Ingest directory contents +- `workflow ` — Ingest workflow documentation + +**Examples:** +```bash +ff ingest file ./docs/security.md # Ingest single file +ff ingest directory ./docs # Ingest directory +ff ingest workflow python_sast # Ingest workflow docs +``` + +--- + +## Common Workflow Examples + +### CI/CD Integration + +```bash +# Run security scan in CI, fail on errors +ff workflow run python_sast . \ + --wait \ + --no-interactive \ + --fail-on error \ + --export-sarif results.sarif +``` + +### Local Development + +```bash +# Quick security check +ff workflow run python_sast ./my-code + +# Check specific file types +ff workflow run python_sast . file_extensions='[".py",".js"]' + +# Interactive parameter configuration +ff workflow run python_sast . --interactive +``` + +### Fuzzing Workflows + +```bash +# Start fuzzing with live monitoring +ff workflow run atheris_fuzzing ./project --live + +# Long-running fuzzing campaign +ff workflow run ossfuzz_campaign ./project \ + --auto-start \ + duration=3600 \ + --live +``` + +### Worker Management + +```bash +# Check which workers are running +ff worker list + +# Start needed worker manually +ff worker start python --build + +# Stop all workers when done +ff worker stop +``` + +--- + +## Configuration Files + +### Project Config (`.fuzzforge/config.json`) + +```json +{ + "project_name": "my-security-project", + "api_url": "http://localhost:8000", + "default_workflow": "python_sast", + "auto_start_workers": true, + "auto_stop_workers": false +} +``` + +### Parameter File Example + +```json +{ + "check_secrets": true, + "file_extensions": [".py", ".js", ".go"], + "severity_threshold": "medium", + "exclude_patterns": ["**/test/**", "**/vendor/**"] +} +``` + +--- + +## Exit Codes + +| Code | Meaning | +|------|---------| +| 0 | Success | +| 1 | General error | +| 2 | Findings matched `--fail-on` criteria | +| 3 | Worker startup failed | +| 4 | Workflow execution failed | + +--- + +## Environment Variables + +| Variable | Description | Default | +|----------|-------------|---------| +| `FUZZFORGE_API_URL` | Backend API URL | http://localhost:8000 | +| `FUZZFORGE_ROOT` | FuzzForge installation directory | Auto-detected | +| `FUZZFORGE_DEBUG` | Enable debug logging | false | + +--- + +## Tips and Best Practices + +1. **Use `--no-interactive` in CI/CD** — Prevents prompts that would hang automated pipelines +2. **Use `--fail-on` for quality gates** — Fail builds based on finding severity +3. **Export SARIF for tool integration** — Most security tools support SARIF format +4. **Let workflows auto-start workers** — More efficient than manually managing workers +5. **Use `--wait` with `--export-sarif`** — Ensures results are available before export +6. **Check `ff worker list` regularly** — Helps manage system resources +7. **Use parameter files for complex configs** — Easier to version control and reuse + +--- + +## Related Documentation + +- [Docker Setup](../how-to/docker-setup.md) — Worker management and Docker configuration +- [Getting Started](../tutorial/getting-started.md) — Complete setup guide +- [Workflow Guide](../how-to/create-workflow.md) — Detailed workflow documentation +- [CI/CD Integration](../how-to/cicd-integration.md) — CI/CD setup examples + +--- + +**Need Help?** + +```bash +ff --help # General help +ff workflow run --help # Command-specific help +ff worker --help # Worker management help +``` diff --git a/docs/docs/tutorial/getting-started.md b/docs/docs/tutorial/getting-started.md index 2049963..b376258 100644 --- a/docs/docs/tutorial/getting-started.md +++ b/docs/docs/tutorial/getting-started.md @@ -28,7 +28,7 @@ cd fuzzforge_ai Create the environment configuration file: ```bash -cp volumes/env/.env.example volumes/env/.env +cp volumes/env/.env.template volumes/env/.env ``` This file is required for FuzzForge to start. You can leave it with default values if you're only using basic workflows. @@ -89,9 +89,26 @@ curl http://localhost:8000/health # Should return: {"status":"healthy"} ``` -### Start the Python Worker +### Start Workers for Your Workflows -Workers don't auto-start by default (saves RAM). Start the Python worker for your first workflow: +Workers don't auto-start by default (saves RAM). You need to start the worker required for the workflow you want to run. + +**Workflow-to-Worker Mapping:** + +| Workflow | Worker Required | Startup Command | +|----------|----------------|-----------------| +| `security_assessment` | worker-python | `docker compose up -d worker-python` | +| `python_sast` | worker-python | `docker compose up -d worker-python` | +| `llm_analysis` | worker-python | `docker compose up -d worker-python` | +| `atheris_fuzzing` | worker-python | `docker compose up -d worker-python` | +| `android_static_analysis` | worker-android | `docker compose up -d worker-android` | +| `cargo_fuzzing` | worker-rust | `docker compose up -d worker-rust` | +| `ossfuzz_campaign` | worker-ossfuzz | `docker compose up -d worker-ossfuzz` | +| `llm_secret_detection` | worker-secrets | `docker compose up -d worker-secrets` | +| `trufflehog_detection` | worker-secrets | `docker compose up -d worker-secrets` | +| `gitleaks_detection` | worker-secrets | `docker compose up -d worker-secrets` | + +**For your first workflow (security_assessment), start the Python worker:** ```bash # Start the Python worker @@ -102,7 +119,20 @@ docker compose ps worker-python # Should show: Up (healthy) ``` -**Note:** Workers use Docker Compose profiles and only start when needed. For your first workflow run, it's safer to start the worker manually. Later, the CLI can auto-start workers on demand. +**For other workflows, start the appropriate worker:** + +```bash +# Example: For Android analysis +docker compose up -d worker-android + +# Example: For Rust fuzzing +docker compose up -d worker-rust + +# Check all running workers +docker compose ps | grep worker +``` + +**Note:** Workers use Docker Compose profiles and only start when needed. For your first workflow run, it's safer to start the worker manually. Later, the CLI can auto-start workers on demand. If you see a warning about worker requirements, ensure you've started the correct worker for your workflow. ## Step 4: Install the CLI (Optional but Recommended) diff --git a/docs/docusaurus.config.ts b/docs/docusaurus.config.ts index 3630bd1..1068406 100644 --- a/docs/docusaurus.config.ts +++ b/docs/docusaurus.config.ts @@ -100,7 +100,7 @@ const config: Config = { label: "AI", }, { - href: "https://github.com/FuzzingLabs/fuzzforge_alpha", + href: "https://github.com/FuzzingLabs/fuzzforge_ai", label: "GitHub", position: "right", }, @@ -160,7 +160,7 @@ const config: Config = { }, { label: "GitHub", - href: "https://github.com/FuzzingLabs/fuzzforge_alpha", + href: "https://github.com/FuzzingLabs/fuzzforge_ai", }, ], }, diff --git a/docs/index.md b/docs/index.md index dc0a13e..7d2cd85 100644 --- a/docs/index.md +++ b/docs/index.md @@ -89,7 +89,7 @@ Technical reference materials and specifications. Before starting FuzzForge, you **must** create the environment configuration file: ```bash -cp volumes/env/.env.example volumes/env/.env +cp volumes/env/.env.template volumes/env/.env ``` Docker Compose will fail without this file. You can leave it with default values if you're only using basic workflows (no AI features). diff --git a/pyproject.toml b/pyproject.toml index 2ee4e56..2e54464 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "fuzzforge" -version = "0.6.0" +version = "0.7.3" description = "FuzzForge Platform - Complete fuzzing and security testing platform with AI capabilities" readme = "README.md" license = { text = "BSL-1.1" } diff --git a/sdk/examples/basic_workflow.py b/sdk/examples/basic_workflow.py index 74b3a49..df55d38 100644 --- a/sdk/examples/basic_workflow.py +++ b/sdk/examples/basic_workflow.py @@ -64,7 +64,6 @@ def main(): print("📝 Workflow metadata:") print(f" Author: {metadata.author}") print(f" Required modules: {metadata.required_modules}") - print(f" Supported volume modes: {metadata.supported_volume_modes}") print() # Prepare target path (use current directory as example) @@ -74,7 +73,6 @@ def main(): # Create workflow submission submission = create_workflow_submission( target_path=target_path, - volume_mode="ro", timeout=300, # 5 minutes ) @@ -234,7 +232,6 @@ async def async_main(): target_path = Path.cwd().absolute() submission = create_workflow_submission( target_path=target_path, - volume_mode="ro", timeout=300, ) diff --git a/sdk/examples/batch_analysis.py b/sdk/examples/batch_analysis.py index 5ac46bc..77aab78 100644 --- a/sdk/examples/batch_analysis.py +++ b/sdk/examples/batch_analysis.py @@ -135,23 +135,18 @@ class BatchAnalyzer: # Determine appropriate timeout based on workflow type if "fuzzing" in metadata.tags: timeout = 1800 # 30 minutes for fuzzing - volume_mode = "rw" elif "dynamic" in metadata.tags: timeout = 900 # 15 minutes for dynamic analysis - volume_mode = "rw" else: timeout = 300 # 5 minutes for static analysis - volume_mode = "ro" except Exception: # Fallback settings timeout = 600 - volume_mode = "ro" # Create submission submission = create_workflow_submission( target_path=project_path, - volume_mode=volume_mode, timeout=timeout ) diff --git a/sdk/examples/fuzzing_monitor.py b/sdk/examples/fuzzing_monitor.py index 096574d..07c4e06 100644 --- a/sdk/examples/fuzzing_monitor.py +++ b/sdk/examples/fuzzing_monitor.py @@ -193,7 +193,6 @@ async def main(): submission = create_workflow_submission( target_path=target_path, - volume_mode="rw", # Fuzzing may need to write files timeout=3600, # 1 hour timeout resource_limits=resource_limits, parameters={ diff --git a/sdk/examples/save_findings_demo.py b/sdk/examples/save_findings_demo.py index 304b17a..1d9568d 100644 --- a/sdk/examples/save_findings_demo.py +++ b/sdk/examples/save_findings_demo.py @@ -33,7 +33,6 @@ def main(): workflow_name = workflows[0].name submission = create_workflow_submission( target_path=Path.cwd().absolute(), - volume_mode="ro", timeout=300 ) diff --git a/sdk/pyproject.toml b/sdk/pyproject.toml index 2afc681..694807f 100644 --- a/sdk/pyproject.toml +++ b/sdk/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "fuzzforge-sdk" -version = "0.7.0" +version = "0.7.3" description = "Python SDK for FuzzForge security testing workflow orchestration platform" readme = "README.md" authors = [ diff --git a/sdk/src/fuzzforge_sdk/__init__.py b/sdk/src/fuzzforge_sdk/__init__.py index b0da889..d50f599 100644 --- a/sdk/src/fuzzforge_sdk/__init__.py +++ b/sdk/src/fuzzforge_sdk/__init__.py @@ -42,7 +42,7 @@ from .testing import ( DEFAULT_TEST_CONFIG, ) -__version__ = "0.6.0" +__version__ = "0.7.3" __all__ = [ "FuzzForgeClient", "WorkflowSubmission", diff --git a/sdk/src/fuzzforge_sdk/client.py b/sdk/src/fuzzforge_sdk/client.py index 1319389..c4f29d3 100644 --- a/sdk/src/fuzzforge_sdk/client.py +++ b/sdk/src/fuzzforge_sdk/client.py @@ -440,7 +440,6 @@ class FuzzForgeClient: workflow_name: str, target_path: Union[str, Path], parameters: Optional[Dict[str, Any]] = None, - volume_mode: str = "ro", timeout: Optional[int] = None, progress_callback: Optional[Callable[[int, int], None]] = None ) -> RunSubmissionResponse: @@ -454,7 +453,6 @@ class FuzzForgeClient: workflow_name: Name of the workflow to execute target_path: Local path to file or directory to analyze parameters: Workflow-specific parameters - volume_mode: Volume mount mode ("ro" or "rw") timeout: Timeout in seconds progress_callback: Optional callback(bytes_uploaded, total_bytes) for progress diff --git a/sdk/src/fuzzforge_sdk/testing.py b/sdk/src/fuzzforge_sdk/testing.py index 9f9297b..6d191b8 100644 --- a/sdk/src/fuzzforge_sdk/testing.py +++ b/sdk/src/fuzzforge_sdk/testing.py @@ -193,8 +193,6 @@ class WorkflowTester: # Create workflow submission submission = create_workflow_submission( - target_path=str(test_path), - volume_mode="ro", **workflow_params ) diff --git a/src/fuzzforge/__init__.py b/src/fuzzforge/__init__.py index 3846ea1..87a087f 100644 --- a/src/fuzzforge/__init__.py +++ b/src/fuzzforge/__init__.py @@ -1,3 +1,3 @@ """FuzzForge Platform - Complete security testing platform with AI capabilities.""" -__version__ = "0.6.0" \ No newline at end of file +__version__ = "0.7.3" \ No newline at end of file diff --git a/test_projects/android_test/BeetleBug.apk b/test_projects/android_test/BeetleBug.apk new file mode 100644 index 0000000000000000000000000000000000000000..05f8f51d9750b208aa8c43db1ec442ca7fd3e391 GIT binary patch literal 9429128 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%0DL&8i-5Xhr zMlgMHOC&Ljli)e}2(p@g;8V10Oeb(zrghvSe9Zf03nq#=li(s25rzy5-V8X4`383e zLX}3z7eNAWjzws80GwYDtKa}u+-~B%-x~6hiA*O z>9B#1yt_Ofi9_@%Ssiy4Xfn%GH7QK6^L>egzq`tWm9#KTgEx^e+dq>8-1OZgD|o_j zni4U8`#>M=yWdKrXjq&acx)TPVE=r#xAR=czHsYqxNRMCm10}QEbN1x(uPc7I1=?r zZ4J-wRDAguY+>!|8g5{fuLcshnir(XSA3aK?UP(0(|Sd6=3adPiW6U`^UJcOJ)Pty z+_VQkh`rats%~NJ>TmKXb~OhF&DC*}!@EwpY)0(Hrw;X-a>n3El^8QsV$7@Z)u*Jy zpA>18BOfwU$70^gUFl3OmUrJ3AE8bMT)-e7T9 z`F<+jAgMy>p>bqcr)$dH@~L!%+&bN+V8ey!b%9gd1KLuAr9|^34a^+dJT%<3Yf|Uc zw)eQVy^4c(1NL-PUt!9rTbsHb+*cEi5ce?~S~4T5ZfJtWY4^HH8}4a@5!>m8l$U`I z?CWgHtg8~!yl=eX{Ai2B^RZ==vnOg+Ive8T_I%e9A?ezsbVCI(cynD&@Z@Ys3a;lM z-?V8txGC+*z^!R5Q>?8MXH}}ic+JMzgj*MX#wSptEb$50UYg(Re2@F-6;3oH6|Q{D zw0i2bVPNj2VOWf$Yesk}RpNxZB~gZ~8cIN=mkDJs$fx+y7_DyRO)GC2Iki}xUbB0S zd)H1egTckq&3SgWsQckm27}^3W<4LwXU1OqQa+ES_>3@|h>0UZ;9*(U(LBYzG>bs8 zvVXaNy)5^)T47}bQ1FXaGzvuk=Q4{Xfym7QJX17+|5K>PN{gTjMPV=o-!ibjnhRPz9c&0TQ*OAY%)sf2ZiQ64{2dhp8 zUoz|IU@oOGh{H3_9qZ@BhCMXmr!jLgBzSdqoIPL9O}wrP8H6mCbwjYQ)w-D&W@f#{ zL=4l8b}*gszAn=d_d5Lt*4`}4AvUd@i^Q*v<%#f+rdDZQd{DQh!aYZ@Z)~%}^m|)h zFUypY8Ev~_);T%{$!5JRD|EHZ5wqSubMm_U$qfFkt_|>`^4_-!jtn{5Bj(vPQi0OJ* zd6mjVbl?X@2?SwG^l&_rUKQ8Fk<@-;Ec9@&1FDAQ4@WA#URS{b!XE3+gl|i`-ty z*rQ;kV9$b;__^Z3m0WivueTECt?)t#HEiN5fm=8}E1(>k<{%j9tyInZMVaopAE>_vO=we)CeP*$PD!dyWOWeCtwn zbzcoyUG+~eTXWvF<}~KGAX%wxTd7rP=vGxjtBPGr)w~k7%|a@UvuRnXkwvXuFy+1I zs{C+pWEq$+Y4oKXT4x{nvld1uxU2B7zV&D~m-4nOKF?a=JKU1T&Cp{RW9%{!Nc9n` z{6sAU-;?=V<*%>KP-F^b-)AU%E}3|Yb+_}P1Tflx6FBuMDA8+>wFW}XiKRt{1=FHK z5;i{W?<1kRj8x9m8SqTklxMigz|b{KJX{7q!a?F{Cn%(*#|T{O&hiauO}XLx@R?a> zrV-s%U}pG6jx*~z*dR7!Ytsucr%o8ry3S;nr}e6B;23vL9pr8sQ7Zq7@9(`&*&d~< ztwcv`hEbr|*0QdrY}8k!G`hUKctK`+$m}!kGN%<9Vhp-e27t`leUpdTEVQibF5P}t z7J%F-wt_^Rdf_03DuypH8=Ed^c~SFIXMZDPlZWXnlPfcsDi(7_@S2(l@=WqeP9nW{ zvUJUHC>85;$K}upwij==xC${0?QQNOPbCXu`(9n;3~|+rJD3_7MO^N;t9q7Mb(DnD zN=vTTO`Up)@U44nOd;5IP7O@zD$dsU>MrAd)RBwb(bB!CcU1m;8{KMC#eH9TH;mY; zYCMjl)6$@Yk8*Bes!Y!%+=QSu)|AyI!*Uu5`y-hnF^7-j8R;`>)M}}3UG#C%2hoQX z8guWkuUaUrni#s*a>I7j(Dbl`TbFKEJ}HbWmujOU0jZUf*W0Du9WPD3P?= z#a$Xk*0I`v>p3-|mVD?f;qHkQkWq37)|aQuA&twUGFK61abFvjEZB)qNdO|xX5I2r zYf2d&YrR>=#>-gCP@=kQw_;Bge|5GF+-5G9oYh$urGb~mnHi;zW5%o698oxJZHOc< zFYc8#cr3GsxDcg_qt-f_o_~;o$SM1 zR<&({xbeM+G+V#_BfX`j#&@eOW(!+hQ&}kfypGAoNqmMQL}f@6SoaFB?_9+=X|Z4V zh#ziGlyAJjs?8FOfF+4{U+{A_%(5_6WC zV|6scwx@U17MXS`!5Qr2;#oMpTDDvB&aT2@18zc{J>@o5KwKM}=l&&bn!RO0R{3D3 za?UIhPo0fMiPX~DIU5%Da%-2VeeGhYQ_dc^<_(jwi$iX=4GjHf+Ag>_uYWO2!@hx2 z4{^}+n{GoS;3?A_rdFyXgc%)yV@|slk(q1-*EBfd{-|E0cdIKe*4=}Pt`4-`#sdnQ zM(R-@vG$85>2~g2i-d5b$b`L(uPDK7-{toASyyt1$3;Bh;G-+!$DWl%)<4dU%e~!; zXQLM)Hba`iMon?6MFwT9tZ*;Il#Gurdm z{IF>&&{?y=a@Wz$ZY}k8mu9@TmfA$0*J3ddI%C$|P7RYPQhT{2`V=`W12dVjI^HDL zXJh9qkZ}0mC1~>bFb5jJM0B0UYJnMIOj;H8$iV65Eq9rjm7pC zo2BOZ`QF>Z02UdqJgfDDXSWu~@Ra@b1Z_E>Wufk@oWBObo?_ssqY7zjK8QS*1vF1# zJ-`2>3Jiz97N1}Ae@e+$Ei#XfwD@$SQQyJ6?%C+6;dD6Q>TE&a$aubGO|Ip*kD9Cv zp=gE4|`t@>_oYalny@Ra#h_ZM}!;#Styfh{F+ zBHnfxdHX7FUn!;|)gYZ}n}&(IV0Xoj z)2<&>hzA6Vo}_lsz#cmX2-(xVo>ec3AGnxRY)qMgjrfsBs?2gMj|7BWj7j+hanRFr zw?W4PJ2XyWm@5J;t`KYl%(QIA1ctL(xp82!kMw+k@ZS!O#{LPG7KJUWBK|PRC(nFy z1&HrIGP>}C6h^m(Pq_jLi~|wcx~}hd7ay?i-!p3YK{@1xZoT@=Jj`T{-L}e|KPwDdJpd|* z8%35l?C4HCgS&$CJ88zmW(UiJR&9c(ud>aU}dLRYJCU36L`4BaQPF?&(FzAnLl&Z$gy2Z4(iV z`)=~>k1GvmC}-BHyLUlV7pSi;=6s8sS{kC$bAMJkg+q~pAy&e-dnMzEm%Rmk@2JdoVra4cpo6>82 z|KO9asH6<<3bE&YFuA!A;Ehc&WpqJ9FSRqs=eN{za$@zvgT!X8%HWE{=k7Mc*-T{C z46&iy`O~_QXt$BnUb^%)C@Mv9lXNkIJzq4 zGTqRJL-*Ldug}dh*p#Bu3ly#21)EZZ@;d7C^uI*AicU7ZvV}7N^lyTpnt5BsE<|`u zVh~8c;ez~r=fnN$-0(Y3PMk}>#5!sNRi@|NpQ6&pq*|G|BAV|A1j1^3YEwM%(yj)Z zG#OLRYYDHJ6v0hSNAe?JuUok!kQpt#w?`qGE=qo4x1oFz!`?T>9KynkM?ERW+_7EW z5uQ5-`pi(50E1jXaZc77IS}lccrbZduWewNeQ|GHoyS;RK=jjGN?vZ@C6Q`E?w2QZ znQWa=&xoGqcD131)lwrFV(f0u&OaWa`+%X)!jHQ~z2Ft5LP2_)?(JUTtwa!z7~(;; z!N>u0b8y?%5VS(ZK@nJ|v@(uGc^dP;(lw%T%G$Vz5zw`_a&-liZx-c1` z7}7}T$5nxV8U!c?b7Vlh3IKKJ09z+u6#zj>FbFrWZ)%{f_U;S1uuI*^Gf7`Y=RG00 z%`hQ;*9SQykY zd%vQ1OlFjv4`isKO+^!!iY73B7*^MDf&k;FZMriW&(KH#&8NPg)Nu%4E#R;QHJw|z zi1x0!43g=9F@V9oU&`)y-q=m7#)d1=XIben&!7^DYeI0vN-mvLgqpPJL87KsnXH8| zE;jquvRTi~mg_`ULC=kaSE5TG^L1&(h;d#s)t-1|ftl&OU1u;bX{i>6VXhn6xlwc8 zaaHt+=AHthk;WCb05DJj64MKKGk|aca029Ae=r!t0gVY6$S0!!C0?tE!TrHtl7OaJ zKx8nBbLfHqiTaJfLp)o=7YG>uiNqoiBwZQ6$R{RI5%QM zh-YwOWjmVavlqnVl)=#wCifWF^nG@nnj4L+W{p5q7i<%0Re&|Y`Tjhn7DT`Qs7G#Y zqU6}RzIJoX&&Utz)MXCGq?OiMnug|BF3_Q|P%xKk_7Yte!*#Pk=2RN4a9TOeSM!}q zo5UELy;E+;wsGFDaJ37`%(jkEf4rXE^W`#JY-gDCSxu2AuqUfalW0|CB-g1b#qrW} zM0YU)0PAQ5iLhSm5!sKlKO!%}G6@@mx?)~;%OH2hwk*%=J`mZ{y90Zt8|lKFvO+4f zbr-8mb6VY04(qP>NbRI4*@MlNug+>u-`NnjVb-$<=^WikClJP^PZwqzx=Z`U_vX9U zX4QM2o3@(PjGH*))G?#0GJo&w<&j4Ah^CR~Sy_L|8ry2=#{KyF>je9+>69Jj@V8YI6IHKe@ zMC0H+{8^eED8{YgY8_K@R`evyf^%~=UT1z<{Tc_M2!LT8p6BP*xcxkeooHSJHn`Ju zpt!s04e7PjD8bn`4%5-tbR#hVL*0<#pDzk>eW89Z*n@^kks7cB%|jCBNB5L1cLfiO zE1A%Sd=x=*N@<5n19+oCEeDAU^sK^cTGxoKY;1Q<1cD>YvB*2;4QBtGcXAGL)0mzA zagsmr;?zM&btJ-H37k1gAY4rDiTQB3QUz*V1uyp2CLLNyFwgzDs3zT3q{wV^mbEfN z96uaG)hQHCV7%HB1X4_w%J9KG@zaW*BoDFf0Zrb$H7bL4X^z5u|4~{bIor6nNCT&* z3>`h`C34G

RVP3-U20h7T#FXC4>wf+r6}!@~6;$dn{~T2={6ES~Us0X?&GUP(02 zNuWWKyIo=K^K6zxHxr@zbd{w$uj5xe)Ba=YBe81LXcBLUW{L@< zu{d=F;a5k`rx*1}=SbCg99{!>P?fM(#yF9Tx$+%kGGhZDAk=zB3Zt@A-78HJ2R}7L z$AeG7P*3^#*-Eq8c~Y+4pGK@5<5r3xMXlUDWxnX2`wSAS$L+4YdcgvmYu<6o_pV~D z=eT*2v|>L(#5oCc+;9UYW2Mp_JWM_0?6#479e90{6=6~{_K;6xGRH8ID}rN3Drn*f z&f@YIakiVRCKI7?p=ivns6$KVI1%A-A!EY%EEjX&B#j||jTv{jIVa(=RBVn*s%1uN zU^8nSkuP_z<2(BjH|g7td~UTl_+aeQx(1h~^6ITb=7IWy)_p8)?PPVz99WByp#cwk z51#JZh7^ihnq9Q!*wpsPOWi$kCY`fC>L7`XJMNZD+-JI$-W)F&Yq49(yYJuI6(W)b zm@oeR{hToV{^MK>`u-!^;+g;Ne^1LQ7VB>o>u>fSd`clzV$n@(ha<5b>NHEUU5{Vq z%c#J1eEx5mHD@M2$w~gb0iB*QfAy7>TMuGQ-z}X9Y zh+~{DEAW|Ma?b(+F!{43cfTcmO#a2hk13p|WylF^s-#ILa@0+TMC8w+gwSbbH7p+< zQ6F$koZv#rfDm{mlTfz1HWu4m%h>W-L7Bo4#--lDiue)<+%3?Qlf@ROx@ywsYT4^5 zhDoe+j5`tA^>_*5QKhO|isfmvGcWAnF7@R+sHMbXgWV2`avVr3m{0GjjrxG1o>c-8 z*HksMEGY5yK|d}H12?*>5b(vm)fNL@3$a>_L_n9_gbhDpnvg)p%K-VT+N{528cIj! zO}O%}_iPFOg&QX=pS8+WY&aK!tZd*ob!3YZ9J&N}MIxaWE3=lH71!ony2m9n?B4H7 zm<}VIFF2}s|Eq;Yyx9FqMH-O|xHL~y@!y-<0%6FJFKMyev(C9E`cIf*@N5LpPKy9J zudgH=&HeaMF?k``_VgP*_Eww}3p)87hsU<|(BQF)>>G9lNc*ZxL`}83us8)6H zwtG3+)#A=R7_#KpDhfx9Ufq;V3yW4^B+^Dp`H`ylr+d!8o9$f~7Gu#eq_t7d{Z8X$ zzmJJdX;#6F$%I1i^Kx3EgAxO6Mx$U6zuTRvU{c_S#3~m9CEzY#5}*aF0+ItSU>ERa zfGh^+1P7bPiDk_Jh2 z9-{z77eZi?6i>pOB#o1VIc)+Yu9J8%Nem_ldR_#GgIPYI@ec#>OiS#ve4>97Abx5| z|3f12kOV9emqoH+5qFEEc#&WiN#iQ{y-I$slHygOv`Pr8gs?sZh;t+Ej09`MfsyDM ziG&e%Mp9%X(MEhR5*HdkGDv<(l&n-8D`~Kj1}kx~@=2<4n?z!hNNiGBHi^q7aoHs8 zn>gPjN}EJ!lVE=nU%W)nOU!~WgXBw)dGgnl#8JI7>PruiN zD>Co{b}WD!pNf6HJzxS@$gju`nHd1e;`Hd+3-C~n?ku%%NMzkU8)> zDlk28lO}+gK>%LyB{1lpt69{-thF=^d4?Nd0MvG#dry?7k($H2s^)f3jT{r&vgXDp zi-!}}osz^f?Ql-(cdNZ>J|C~l3tQ|Puxt>~__MU8cf@dOC+CO&M~2u3@OEpa&DZ5L z11Ife?AoejI!IQA_Lfayob>}FY*sIdEwfn<%)8!%l}^xY@&NpIS8XL{)(>4-=R=~J zk#*tLS~Qr~WpOL|dTdq2#N<15uj!wE+NLm<=V02Z70N|K#SkDd9cIukBRqLiR#o$g zE%V*EMkn;*NL9NOKk=gr^$1o@KB*07h!r|3;9!t%owa=Sw5AUzQbNcl9H8ao8_f62nI$V8syURx)r!~Q3TEG z(M*guYR2fm9E(YG@z|x2A!iRx5TaW1*^L5}fV+T6fEKVafM!Nu5Q?K{K2>0F_Y5ZS zY!c5V`4T!40jNjV6k-@G^2s99Dgi-3Az&nQs3h1vG6;}Q?9O15$Zz7yCILZ7C-9rR z^YYG1JiWv-h%Z5+1fdNek=P|zbkYQ#66{l$Z}zjNzOrZk6l);Zq23I{9px|IY1uIS zcY?Y`f|@#GGd7Qw zz-vBuvAMiWO9Ws+hT}MzQ_>QZX3%_Qu&uz^SvXPXUFg+2sFk?Aw~9IFdB`x&F(+W~E;1-;-69Rh1{RGLnqQs+093Kx)vf)!oxb zty@cU142k3ZW0F&=;7?V&Z0GIYnXYdF*pautSZ9YGcs-&R}T+& zST-p`-W!z#J8G;fYk$rOLkvXJe70Zerebp|GN9-s?~2Gv#|?wVx_HF|R20f^D>dVy zkW3m@QC(swNnsj(hwt-1!pVf3Wx=CCriu-1e_;DO))b5rG}B9tDqsTo+wteX*kP6vV;B`suhUVGt8}q zw4{<_Pi2j=4sbB;r&dCAsGdlTQi9l~OLw3c5|1}&M-DYODZXu{xP|*JPw28QmPq}W z>z3v-nA%7fa1h^qQn6h@H9=D&cf!iKN(PmpZB9`Dwig4%TrRo1tx=N+{+OV|%B%Hu z6q}plA%H0m3r|MLIGrPnhK2h49IU3WQ=$0YEHp`V1!IF9j?Jy6Jz+tppO=z*UX9Gr zVFb&FS*&`;530{OW!h9SfFiSpT;A-h9W&V=Lmp-ot@0 zX%#6DQ~Aaj1Ce^V<5WLO+)M^xbFpBLw7Cn|vfx*_yLGMTJNNBrC^VvYuLKL!kraiP zpH|K`CIKz&4a5_jJE|CFFz__5M0W+_Av$Kht}4=z=(wXbP9rMJRZ$>ry)vSelh)8m zM5TgCx3W{NH_elDHT8?jC7xt{DzQu@OH;`Ut-aZk7iJP< zCP6ZZER*bJ5+pk=p2V3+26rV(yHcWDa+XV$a(O+M*K^5IE)|kXCUU8QLcU5NU!{-= zDI|l1q*q9Kw83XjUZ2Z*bIHV9QlHCvb1B1IQlCo(=Mu|YN;{X*&Lz&dc=IrS~6ct zkXmwGOLnyc(Nc9?K#-9cy53_(pVG%>=@_@$nM#-f-^INMZpOg#G#Jo! z4Hgo^!*s^Ik&t*w(TN_(mPQNjf_!@?+t18Bm7NxkWU-WpFhmSsR!-V&RCJ*ve%00% z@+=Vs-6mDz?xu07O@J!laxlpHupF|?mEHZ5UuRwvO$a7l~iIXue%C#b5`BJ&HRJs!CBCeXF!zIDrk ze4Fq9!utC=c8ls;A7O$h32{$qit_(bX=OXjT5s0}fi zK?$4NdZ_8kAM4Dl5rG|($!Dkyu1zu^E~3(6Q_Lr%se7cQW+=r}02>A{A>0Z7REaY@ zUnPsorcH4T!O|hued?kAw5%+m;vugZ(ZbHkMzcV8HRgwu!4x|pa^3r>JivmPTo+f0 zt3A3I;E20O*rOo`9?jNlQ5j1z0cffgzz9&KBM7Lm7Ba${sm*<=sqS`~dYH*HD1-NR<^Phy}0m*eA zBcsk_uUb_w*+Gs;8HQ*Ya4JiNPFNZVlme75n~6Si@|9Jjz+l(vPZl-(kculaOu-if9+)WKr+&0LW&MB@V9sTXcgel7iV!kFNEn4cC^G8!aLoJMATK+ zCW?{OX9lQf*=tY+h4pe(H1i=>V9`LA+epMD(W48bNUzD|Nm^-F7N7x6`3jO=q4>^R zrN*;FHp~PTiOw7h<%7~IEX*~hW_XyD<~1|RL;{Xc!xt|JT;POGfzQ@WGFi{G^F(+?jJ;>8Bv9}7T1mq zVmH3Ez&vq45T3IRAO&l|LiyZ5w6UeB9Q*?E=IoZEjOG?pX`L;=%3+^2^Xy9)z6is9 z#StLmt8|to1vOx&4piDX=TmWQ)=H{JNuCwB74Rmz?9DhdcF+|Yj$jX6fxJrIGZKV$ zbrojzt`XD5f}Lg*Ov)Zdt*Hq+Hl|6cyAEE{SP!K-3zSXm;*OTDLh1#Bz~GVvIr}CZ z$>4+gd@MSNps1&YdV_&7AOiKuDkQAx1h4Qc3x2eiaS0YI#R@N2d(k3iNgtf*uBGNO6Z*ZzSv-z&Ls_dHA7Mdsd}NV5RQd54xMjzSF_z@;>}fVYWDXz=RfFT2CE$-Y zNkQvr<>r~=R8VS%;<<_-j5@&a1{SMYlgf~Md@&l-$Q$KlT>j=a+`emcFj)uDk`@yP zc{yz{goo-84x7k*bMiCmB1bju5}^(Ov^Id`+Z{J@DeVrm(31SntyEZp_ZkP^nxRDbRUK?R4r< z+GdQ^h*cQiem%-+(g5W637a1qtr#$>7N2sN4x9L{Zk=++gf~*`(ZU*DE!YB4k7kCo ztr3(>QX8JePz|4=?nWe769MC2FW|AX>D)GrbgVIm0B9iDL;Glgr^m)QyeaEdlY9J9 zB}_`8T__-I1_?vVlHmZdI;prNJkawZnPYsXL@@@#<4U3zq13rfaqP2{B~{I@b-E}B zE>kh@#GqAsD6nh8P>BgADNrR9xVPjb87it8s&VUTrz)hHt3sMbipd@xk6{TY+J)6% zC1civT1rn8%(Z$NC$?deX#U~cz2IR`Prc6 zv9O+Xi_Drg0HT*0Vs}}cNUzRDGj@`CTx5V0@YLAwlTepX4b5qZ!OdNQvm6sL)D3M) z@qxNRU9$M5XZzF{eKF`XvavfIqu8dq@55G@VSKNTErrn`?#E zr)s&USF@!-_|P=L$9mEyA&{nBl$pWojP5pkiJ~+qI z?ZG)W-yWQEQ|Q43JB=S)@N@9N#b7Eu*!R=-!G8C>sHNL)b+B(g76r@wOTOkc78$&9 z*RRw5cZbCy(?pw{|8Wf5OIo-tWl7S1{@T{(8aioS@-9DnMcm!}UwX79 z(q%dXr}P)UeGu-I-*IcWSET!jZ{vczqPAQRS8J~h@=FQ*ay1?Mr7jSJdudm2VP4&& zU8q+#?I6@IW&IWH*#&ud}gs%WV+%8&g*n|)cx zEt!o%zBJpLq5fMbzp5VuAzxi7UAR{^h&bF!8vK?(uguxYTTT$@<-Ifr^zweXCD4{U zy}InLD9kI0@Y3XxL06`-ZdmHiNj<%>02yr1>ulxgkKR~;)YdiIK6G4tn>$Plu;+l;`U9r2_u+u=qCXNQW8e>A8ST8DO6AJ|k zr7u@4)J||$$0~JnQuv$jfQv*<8~!a-~=0EXo(FHo2uYrLxD*&RFpVP2&C{z>KPgxoT%Yv!J8ZnRJzo8nYY;;4(bINKtvTstWo%2C}P7tz| z23e2OX_+`Uvj%$zMs|7c8gBWCROz7-b|N9or0H`sbfWQ3U?40W0If7sP=Pufs@@o= zX(XT>`La_%qH$s`Y#H2%(K8hawQI3#p~1xJS&Gp(VT?yRv)9Gi$XyZwyunTlTZm;c zn+Bg}k+P#j$QkE=Zt7YnS8;oIH5T=?CmP{id?*wJ&X(F9Z%TP z){~H{IlLsDOlT+rSb+Bys$d}my8Yo({~Yp(VE0JnDo=B{JSQm5`J)i9Z8^i4zP(c~ zUKj#`{)vZH4q7=HMc>_sBT`eO;&r<72wf&Mzq(AbuFH)w$ktkYG|s18<|sVBv*aF1 zow29+rhAZ;<3^i}C$V0}h^Twi?NRqbY0;BY6ul<~_QYg4Gul}XKyu%k%hMn*v zR*ztMBCU6Lnyx%m&1uYSmG#=_ap_lIRDIqqiuRH&+Do@+8+Dq5 z3Lb>f3lEQmv<`%bI(HAq5$XY}2}}o0Tc8IFlt7Mbk4#f)(P=j8t*c<#GnloR{TYty zAT&Kn8?M#T-LjR!1sAt~K$%~iL?ki16UHSIUs?#;R^vDug)Aoa{=#90F;!j5ChT~Vgk_^Sag^w}C*V{By{*X|sy$!_0j3x+{_X{B zS*qBJYyuPQ(7_a&8dET{x$CZ=1fvz5~3?_~Ud69(Sod>dbuo zQctMiP#x1Sz(>G(MjKUD>eB$uVXHb`Y2e$|S&;zhomqgwE+smn_Aai^FU|PFTG6D` zQ8GkBi~mR?u%m<>nn)=%t6p+jG&F!H>ufLL%%rIHXBq1X)w3qDMj`b6`f`>{Oghe3 zG{LjHp%7#k>x>}ME;iXXP3k@hUm^-`#xvLxWM1A8RsQ0Yg~*Q)}W z+L8sisT^(;L7d=ZzuRMi)W2NE#7wRa)*WRxx_!%}4Mo{PrP^)fqId9mnVGnW5lQh} z72O2j2Rgo9#x$`Y5$;6XKShq`h> z+PrE9>aGeaK=e#TukFTKAen^z6=fW!OjFgnQo*++SV2RSH70NA-=)=45%dD6qzpes ziS6{pdj_{UdtJ6<&H4N!t|>L$=#kWB>Ry$L$b9$_>tw^;6;ty~#(^jMwG2~K)SzqZ zH#eGPy=8EyStW5i8bH~4p7cLVopJl@zpt`5Wxk0WSAnH@<{USZBsQ)>L<~7ipQ$m! zCGPMG>n2XnpnZj(H8keI;{ipg!{8pfe}zI zk`6pLXW36*10sJyq(fM&sTEZR#cDq!8uP^1eyH6@XN2yL<0|i7wABaR4P1`MXVMw$ z1|&keTJ>+>5v835TAXrwQnlBOrJWeNz_xKJEr~`8K}8M5U5C`PPaQK?IyCys z)KMbJ)c7QGl)(IEcWa4>I9%%py`u_6)lhkMOT|@Jd8P~c3frS#cgLum+S!h0ijNjZ zZZ{Yeq&nF{Tdbhv3OqChQb*zOtlCYBJaOVKEak^8&qx(`O%;SWsTZ(f0$p{DxoXF$ zlTX#O#qAV^3ig|0;0sw0$y<>73ze+)T}>F;;9J*H3Dn|P&$rgaF}VsXQcXL;Op>hA zV;OvKEK1u#wPUrLO63^Zg0S1wJnPSfNt7Ncn$@SF52^q0vH`JKK6~v@LD3i)S0BDlbmZm1-6e?5d zC@A*GE?+d2?IbiFY0HlZCpUpbEmSfrQV4X9aO=snsrY7)#*Gx;xeV;zN*^>M{6$NP zHfhqGnVFPkFTQFWP~2G?fhFcDL1xF25$-i;10H7=epmT^Z(-OS*Dj9TgZ<#SAW;BC z?Ligu4(g(&aokoDjT~vQ@bRb`_W`U=OPz9@?ul%v)S;U~OprHTcfp0`2?55r1DbW1m@T=%!lJWbYWHhI ziLFA?f}J)h;Rx7dy0aWbm>OUIdoG|6Q)#w9V%EyKA5 z)1ex#veIG`Gs5L|fF*5ra8zQSV9MB|A1?-}CfhM=0*dETZS%Y>7Iu_qaj=}yFxHmR z&r#C0R6AqIH-WS+YInw&&fTaO(W78I|I0=Efm~GKVPi$V(TXj+BcBAfMilwzmF1?c zayPfI^&`$3LDmqOKG=7Qyn}tWK98uRQM!XE)l`6mk90_Nrc#y z(ZP>h_coA+HIRojuNSXZ|5OVz-0(KbB-R_^-&uh1`%0oh?_jizG+;onhQwesU{rC&q;+!6ffzrc77TwmioTR548&=C4k8RE(-gL$^tfk_XxXnc}qPO*>N4YbSl% zh)j|E*ByaXg+!Ghq$qCAa`&MfAT4ozuE>HvIh>WUO=cGx(HgC^S zd!^0FxYjUyr~N>A$appp3)4Vc%<&5$VK|6Y2?E>XjT$*|@OhhyiLIb&=BSaVS#oR3 zApsM${dv+h;XwpZhEdayq1i}_^GDVek4KFX5;hxI?Zm$b_KRo3R^!42i%HZlL7+Mb zYNTcnmhhw0Y+{KAWLjN_$IAiiN7S%hrBjPF;W$CVJ`Pi&O}R-lBs1VyAq{|5ev`mi zj-{stY`90(n!$P?n;14A9acNdk2rsbnxyHOwDXj(Q^H_b)RKe{#bXp|2g*a|az@}f z)E@pBJJ@B?7RHPOAmYex63nRjHKubjrXMvlzV~DJ4is&4AUdDT}kw zmL?JHH3ZGm6}J`IN@kW+swyj_f_YUs?F}H1P0rZ<1}0)KQ|d;1vrGO0FYYC}EAyTS z48fbpz))3AA&!FkXpNm5c9z&Wam956aM`FWaFflXI%Sr)1&8PyFh5wC>S+?Tms~36 ztKabTQ^WfA$(@hbox(*Fd^g&#`fYNt3S{cSdRBpjODH0qqd^X%|Nr6)xs5A@XoJM00 zls~ii>R_;e3g|!xoA3;|4UZ)at7JBY*}?|nR+xg**y`e&^`th5QnK7+kj5-hXhu_D z66Lxl*A0R_*c7__}c2?NCZJhTV{%!zA+#8DzgfRGWUWW&xf&(K`(_KF&q|UUAUKYeK1tq=%Xw#v=AXs>+WywzW_OgWKsvXBJ z=5Zfq_Hl!2v109$+!yYzWFk$1z#t(Obf;FymMJ3fd>c{N9&XTNS~QwCgo>Z5Xh%Z? zZqdOPr=@FRy*MVb(MPe$o%j1)%Ukhigo4E4Ms1<$H;fz*NmEn9B*X_HSP|9k@YU2p z;^u{WI~6>v2;kPj`vi=W3hR3!eMvJ-S@DOw0W$zqk?vWQYtT+y29ac?jm0kP2@rFM zfHLSes#bhWMQYJ1_;*3zr(#aG+QAHrLzVzVZ; zSH#wO*isFfwXn4kw$;J*D%e^B+bdvO`M0IMCGo9kZ%cY>%9{zhYF}j9f*Dj#2&nkN zfb>H(bvk_rro|v@hJ%XTqT@pwuS9|&<)MRp3zp+qn#r2Grrn0P-Rp#e{c=J7mPfHk zfn!0QpXyd;vWut>F1j)7V86?rOwT%nGQlZs(IBIgUktgr@yl`D4B0q#uy_Q?#PX=1 zZ7$SVBQA#iaOnVJ;nC_G1lSVkW?TiY|CEAAIJgAIJbP%a;X9SZ38>Kb$ImyZBU$90~)0EhLHf1hTaZ^JRKfED(DIeGX zD0yuK)s5W18fu8975&nt!Ah?cy2d2mENtw16Iv4&twc@@dVwQVxQg8xF7m|(QskBi zTs?+s_^DZun~u}&xYR5t$4mP0R(Uyx`GL{MLA+rXkQ3eG?P@!k36r3;XC|gCtpJy4 zwLh{Y*j{cVXpz(oI=Cnx<>g?%TaPz5H-YI3o_h6oQFHPQ_R!61I|cMb9os8u55S$b zc`ZZ|`a#)p!_olsVd7;N5$ag)X18i47vblc_7Q(u+hl(jUV#={VfYHfh*1fpNZ~9@0!k&UkBspA(6o&fs-kH?z7sIc%_v z8^ZLNrh3^8lt&YiMY7ODur`FcFjRjc9@2P`K7#mL(riF7{?jD@; za4E)X+^Etpk@nU}!Rn1msqS)RE$6ubsZo?`RkEVGZj^1Hsyiq|rMw~_9HMtHHFPWX z9L@+t(<%)&+eB%4(^6CS*c3!)aYEy_^`cyPM>H*S%`+jynStH4d>V_Bx}p|Y7ci92 z)TP6*k(3<J*@i&sqK?%4-{x*EcA?-k@w%CDGBh>TKw=J-qC3 zpkwD{LH;|BUz&jPT<_HWn`;dEjqPo^YuLIwo@#K*8rJG`@U%7o#@Eg2HjQMhh};yI zyE?)+9jQ7o)C=PGu|w2p#+RGq(}Tnc%PGrRP%jo5N>_1MtJmH~2MPCRq}IKAqnIX> zEGTTjV!0ckYH4K0a3lbQinK(OIk$m)d^l>znWC#OgISMO6rNYo;5>&9uA`P|Xr040 zya9!$u}x1{rZEt`=AnVtNX#G$M`g22OVK^wEIM_lP1nzt3ER}@W~(JGD-9YNmF$d2 z#arRDpjpkPsumlB&C0iw#SX4v%3aI_W?t4?w!jaaSA?t=tO|9JBo)^2Ot4Cd2^!0y z9DuCJ7s)hnerW-#VR4bOue@ZsHRv zyCQSw@)Y@ZO=%J?7vbS#ttxUUO^mGW9Wor(|+f%XIQG`twmkAbn&RZ2erCR$QX zZ5x3#E=?OahiJG57Xn%-FP5onECH=D8*Rx-G8v*JW?`c&MQ1%t%EP2|LF-Xk6q$ux z8%*m=XVVhE{NM-JOP~cJA93|4&?iD9s|taj+BR*PwrN!yTuJAp0CX1DyJd@-Hq9E=(==YLOy&HWR#n^dm+eie(a`Ir6bc3%7w?@YT}=WoRl{ z$mqu<;iK3^mh7U!vZ2~RcY+#dc{)@vKEf$BJbShc(4KAM3a-^n4$~(}TnvMYj1raw z9C=_Bis!2=%VpEO$e>m-?dXIeTP6PE#P28wV+lBnR0OsLiWeEF@DJ~}EV6pa@5Afn z2Et*ed55Q*ON+I z$5rDTcp;Lq1mtO%H>}vkW`an130oon)pX38Py!bmytNUkx`2*xH;O1N?Tq|%;nfE% zsD;DfCIIsl3tGKSiBy%&=rn<>9UKptg}q?j%feU}t(B6es#XN?4tIeC_SDJ%qN~`h zNsv?K%N^)~h5GY{P@vt?&mf%v<0asrf^hJ2;x!5po9HlZnH0l%MLT*d z3YJj+BCcx&gcPdG(g5e{M&x6-T+%mYXR1&irQEJ}r-QVy?B1)BVRVC$ z22Pi}vYO(!Z`8f3XEa16ODjRLgvy+rji)6ylhFiy|6d&+kK zoodIvyg%rCyGE1`Y+($G3( zb0ac*#k3SP2aU#lxCA=k>r;+E^*Cc~@t#7(r2k+k?I%l%hJ}p@D#@9+Rq-;*W*wYo z?C=+4pYoR#W7dx0BBrS-OXf53930(CSZ0X7vwB1Dc%F4q?ZDL%St?UFY~X2`Dc!wb z#sN%gc{R0`X@Rz?0UOfdet)o}hFo|cSqkTIIhT*e9~WO^J}DBbgJfBzdm=)$gfKa+ zspQkp&_5T!YyxrXA}^XHTAWg2w(iQpDR7`L1Ey~PQ`Pge7vY^S1$wpI!7vC~+%5#) z<#p9U)5;jGrsWa!DVW|}s^wr=Q3{sn8m1e$uyb;p zUlA?!lNm@x^_vdU`dRL=GK7><-;OkQ2pKZe;~r5v#d%RedrisyN~K}&H2%Kj#&rbH z(6V|FVxk)K=c_ge#5@SWQC#=gb$tDY1&yLBSxl)_*xy3imcYh=7!UAi7B^kZ*$xw7 z*${s!)v{c562BxzRdv7Gm%Z}~P)zhmf%DY^&n0RT<{bMqWlOu036*fhkXRH1WGzbo zbXwy8iy%qM*Zo_*QVzS5L)6Ov(!S(meQg&lbJ4;9A`-3vmdQxejYn2JOb|u_xy2n3 z6bi-w3qxTcU1w1gifb}zy+njwZKnkc_$tz%*eX~*vq~gdH6QW`N6Xgc%V->=F@1;w z*&b~gDS~ARc#UzWbVH(t&u622)LGUe_;qQ^b7j^sVu_%-hOD66%mfc9Y%Iv>N#SU$ z+-9U7aGq_D%1&V1;#1VV6Fp;EBox?+omVu8;1f0Yn^~7rUdjww>ZuJjKjG%4ZK!yT zAq#s6{c8+D>nSR3o7kuV;f;ulg+mC29vr~O>DAdxLDNpxTpHboDrDcqnQt830%)5i zK6z}LRqtCjtDX+M73T95=5q=ABM+n2O3Wv&XhvoucUXL^n8V6Iu3)xQ;CWnn z5aL@Xt0bIlR$%#MtJ!MCa{C=BOqCUuE*c(GPjMCiVI8ufYJellcNlole9YJ-jYZvR z3WKuHQG2nXD!_H~mEubPqmD}>6wg9kd9z+C zwtBZR>^3PIwOO$|a#SzN!NIxwU*1&(H36}Kja!AYG#QKa48n|P7CE@!c~1uyau_9= zmx2`5OPypn!Qfw7cwS@{P(}d9dpx+Ht(VrGVmX8d`*{a?o81IDs~iArj`w5U;lX}n zzxZIk^+0DQn2;U|@_)U5aBeoDLMXA4{jcBu>pgP*_gjO9*B;(I_VbCK-*|X^@bLP> zn{d8=cyI9V*2C|AKKXEeK;G{L5BDG5efZ$vkM3I#c8#7scz6#_2J&$5@J9k}!F%xV zK6^i(Aj*x0*9Jtn{_`6?p$89d1@L`}=GwzMc;^ApZd%WW_^EsI=Qn;n_45gMZw@GO zdh6$t1NZFI!@EDf0WWyr|9nb;ZV&!`?eFLQ{{7$|AOGXhKhFN+>wkPk(C4l+|M-e% zpAQ~=_2|;$GmrMkeFwhYU^fLzdtM|gZXBK-S%y%7KY-oKv`!kx!&()(Z86du3z=q@FANsxCaBTRow z^2HgX(AQmf3qn=yqpv6t_rQVt;1a)lSpejpa!*Bnbonu5;nKf7aE~uPKJ)muk8Tbg z-9!#0CVNf`D#p+Y(PI+YKEIb2UmPvj!H0-*_L;&s&Z zI9+#3_mxfWw;s5%-P6V^IohtGw8N|N^=|o5>uY(2u3lU1>-o#=-1SKbpsWJi(Ecc1 z$Um2iJ$Ye1d2vGUs$G9GZSyv2 zduuQ{5w_!cRi}9awRI@e-oE~MC+WI;=2N4 z-^`E4agS#a8OS*4$xGCN>*2#v$Z6J_!0o`h6m-Sn0z?HLCKTkgDMSPx78nX%uXcC+ z847GaUaiIc(gO&BE{BR5P@C>{XQNKR5`$w51?`_M#$$h(9g_QqmpI3wIaNv7K- zBWM8krGe$9Crsf26RYETsSW%B@$V2keAQzG-Ym#stU+JG0N(VIg7^Iq6;bQp#Ozc6 znHMNHTNog^_GWGGc8@oe1lc^^ddiG;o%tBK{(J+uDj;yb>q87$7jlAbrTXV`d%L;p zKh8YqVKJ`fPMmjpfX}Bl57!hjGoja;hYA4lcBgl`_RQbddgEX3M#$4&)~;julfZX7 zM2^&AtuD~<#NfG$?yvGC3y|e8OqQfXf+C1jJsvKec)%3iZYngZj{><_S zzEC_>S6I1wJALBMTzmKhqhwSQT?V6nFYokDh$r&&N+#qND3pROyVy3t^73$YAyDrj z7U&^HA7mY&L@Dp)|v(zbcVw|3tzF9v#kPe zx{LK|*$a`Uo6(wzR}Qz!2g;~dm-tNZYgO4gq4(3s*890M?HxZR34`A}4I$gl7ueqS z^FGDhU_6!KM1XRzsQdkyZ&^0s#`6;24k14~85lw>;R+V=Jh{KqdO2umc)K23fxMoq zmvwokKVNpNw~9f%%>Yjw8+ydg$LbxLkyO&bqJ_BLxNtTdR|GU-r)_O4P7n{V*JHK-=X39vAVvhWBn?-vRTH3~J{I(>2@*Sk;VUC7_X z-r4}f>SW^RVqs+B#A;~ZWWr|eXlHNY2(&P9VwPq7JU%*6!^^Y4J2(VSL<}m(S z7Ih1E{riw%U{tVRU@+d{jI0fuoJ^c}*^Eux;uCeO$<*-&-ds&v^>iy1PHaw^En4ez z4C$QbDT^GcS7sw;0wh!M3^P@H!rLHh1 zr%(%e?g}T3nU4)41pXc*DumOlJPOvGtYoYMb+| z`U$s|R=StB`^75q_`>Vsxk998qlH)-4ty~TA3@Y7#?}*eLi>c2MN0Y#X7My7Occe} zWaU$7@=XAEKuZr{kfbw$%0AXJ*fX*9%Q_8!ri0#_HU=k}o?$3)knYO)iXN2toO+55 zZ#GB(@_+v8`ORH$oH3ai-8f!g_wxe*C~);t#ovn<%IJn6;a$Ea39tlM;ry?6w0Dd? z!@{?qK?BDCGFm5NUlA#?YRU4L#G#*8LZGl#DX=_P_VtGtO&22$1N<&WGL1qEv139S z1K}Xo7J-My$Qf)RHXD8#!6N1%QWS#7XJD+r5w#dyMN&<&pktlY^j~pRI;guE=ljFh?pz^8aiPq@ zr$ZV=oMBH z?4imqZ5k2&5~F1NI{`F|e?79cJ~ZOlVjtpi8RS1Zq;yFc3n>qZLaaueRPHNPyEFUbrs)W zGx`o1x+v0}g@eifPj6jbH{Z6rjM->?tGtYZN^u(cx2QJM3O*hqVr#V4~0>y1;;fa(L~)W=m(L4~ICN$QtR%4@a9x-4&g z^;)&8&$HqkDM7J+TSK|(oj=VrOgRf?3vwfE=PJd|7O3o2#~ybITCFpJ?u8V3ita&!D0261mTvlJ5bpt>@*dhs_7o1 zI31h)HW5nA%a2AZ!@pH_KK>w#+v*ETqc@5Xd!-fN?j&*~swZhvD4yYzE73l+A^+9f z=DV|Okz!`C)D@jD(O;Rl=fB*wQ?&q;BUJ~+W1k*Ay17a5)4QD{?Xp6W2O}xS(AOp< zk|*n|?3R~G+w$hrB~25tL;}T}8576@izr1hB9_vE2&uX5P4jrXCyeht?s4h;4uG@-w$c;!C z_QB5rm6FALVAXbG!p^^gZ?=uZH(sOh*OtbR!*a8=dba%QebfA{{j|O6Bh5ODpmS&T z>TyWTxb_m8?&yj$7EQc6K)1;2M}?6Es9DWIh1<=%;gPPT*0AXa7jvOZfcWOZd3Syk zUsls}nc#q5bF(|8JVvc1q83BdBvo^{;#QDpG-0&3A!XoA>gUl&NqQG8s7CWAA zR$#x(Bf9BBPRsC6MX6~gYx95wpRmG2;@MyRg*)otfs2N&Z%DcK++UI4J&O5{wO>K& z`)BwEBKIDQdR!wXcYU=-0{9ESv(Q*@KT`s;^U7~Qqo$I0WuzxSw(|Ja<#_ye2@l~%2tNn#>1P{`q1Z<#R5 zPPWxLua&K3B=Tb6Z^f`l0^;W|j0edfm~|0e>^cOmKSh%k1Yv4z;9~3Y*$+Ijbb=ZI zbaZm5C%(Es{>k6f$F^nF$xdaw-x6&GN?Z)N)xU;N3#wZPux-!o^Aqn`U8~uwv1#6@ zt_~C5`B$!m{v@&%JzrzMsZA~Nw_Pb}`M0w?N^2MGb7n%e?V@7}ELQt%Ws7OJ=kXV7 zZR{%XrQDK(%xUcF;+82$D^R>|MFoL*OyyhQa8I1SWS(i6>U^8{x6<)=9!p*^v{t47 z4cl|sw3I~cgHrc=rFVNDGF#$YZj;F&WM(yD5Um`D)T zf@!yS8Evy|La=MWY?pG6ANA0m%GEZ!t`7VgJ@0T=E2>vCE4gERV>mtm)Eu6Rm6w=kcZ&o@--e8@*Rk^>bcM!%? zeXwct83Hl{TH?vvp=3z(k=7%3C{_&?e8jSu=;L`?D~+_hOS|(`_)Un@|Ydc1JaC_ z&iV=-a-1tG2rz4&ShY(!mbIS3P$&zyS}&|=AC=xG&(Z;c3gV)$ruJ4KfdBgY1Vwpk zBz+(1Kas+~VE*sno|EH0<9%7Ox3$)S^T34HvqfkQqYQzCWBI5+Q z&;NeD{4Ji@j4>`D387+cxUHCAv{(FRLi6v)PhHX+h&+&$&Dc#k zh$>`YGj$UmLJs*1m4$dg7B;0eSs_Lcg-ubM5JTN}rj^a#5LSo;WTJBcO|KIL$_l}U z@NWXT4BWsJ+OQ>?HJhZHqLb(y|2mB}CEp{F+O%L;Mh@ztv&R>KZAW>3|uw&A~B8JfngY`hrFVBh`g!Poj-fvdIL&aQoni--^+WxsG7xpXnoxtc2Iw1-2&? zK#BCnAc7_Af@?&hK#cMy?4PAY&Zfr?_AslM0>Rk6J)0;3XpiC~H~vQYFl5LKoznK$0*Lbd9$m!Iu>PB3 z_5dg*2ZCc3j4AB2wC`1AiNq5%0Zaqmm&jY%x%4LzWcEo(MRU>jWf!kriG!a^+#0Z1l_==YTO- zg_?fZNM_W&m@#s?pav>ot@uK8S9-v8A}H2M;i&_oZ5uq6q;>x7AxG6;J}G z>e*)*2B~|4gS`xbF{6afmqltNI>N8=N-DBPPx?XK3%1`32#w+X?xg!9g4MUpV=s3W zYhKfsgLMRHOagfBUyGTols~S;aed4DTb(EdpWHhvf>uPONugdY;lAoo!R$2%M0W@9 z&X`gA<7G(>>MUZ8L{pE3tOQr$vdJYyDd`c+H;+Ql8cu^$n*&deI1c0TUqAFcaJkX`o>tvo9v*d2x~HNFg(MD zuXJ`69PTKNC&_KOY=WU6^?XQtV4IluH>O0zjqL}gHwzAqF95xj0@~6k>{5v-77$2$ z)>qmSN_;!AUiwOZj8*5z5g5(6vxxWsHuA+P>5X`>+gNd2JJXg<>#i;q+cPszFtni8by@;1$GpWbzg@Q+ZSI>BZCn4lq6QY^02BxzO@ zX}NC`PED&<)Cb+53C^{!CNe)3nv67mvzVUXy;Si~9Q>`)7@vV$$B5=V63n5(%8E39 zrL;R~cZ%c)tKbeY*L}9|Da7QwU~}H#-}wE>w3UQk@tzt|NWNhs0i`dg`X6}umPcz^ z7=@x$G9=@g@Or`4`w3H3qK_*{*2F*$ktpd3+c0$cExcyEXK zt2bkBPYmWGEp=!N=rI9;XT!_|`0=Yfb-OC+PgEF#r184Mg3+}e&gH)c+uRE&ic7`o zk=nvlyos>EL{XpwW6+ioTU|%}M!_VbB%Ax;md-VWk_?g5lj2zuQ)9u8#9#sh*K3cp zikQ87KxMJJcuE$9zkYBOfE|yLzb2(d~$-RDytHX?g zNPfPOEzn~<%my>Pru>V!o7Y1)&{#Zj;!XrR1NWXZ&Tcree5K4k+QzfG?pkC^%+I{f z3ENPGCI2)y6LS??wmq#XC2u@A-N=>j*liVFUzt2(91FkN(%?{AtYm!NxuksECT?!k zjrvL4MKe8ZJOcA4pip;ItPpFAfZlP(oFjppolHsfm)6wW*E`2A5ZJN zVcN1(b*@CsLw7gO_Sv_)*G=s%mMl3V322r-1?#TF<3(#6bF>l~#^R%YC#`RARPCDs~ zbWK@vGqPVU)I|$a=Yd40O>JF4>Dj%ks)9#yK|*##UFJq9I-2{x3rOlrT;KVl&2S|@ z{Y$&Mt6br;Qfmv{zh7N$ZP(y3HwS_dDCxymRg%0?c)1!>v$RU3|=O$pbS>>gL!nl@>iH{r3WsuSgh zYPH||<^OnRN|#C4^@XewKFbFtO;Smr=O zbh~BFX2%u@R<|NrL?d&p^3+m))tQpU-+;>6MgGlk0ZI3$>P{=;)W%|GaGjcBPHUY4 zf_J;l<3wv_Kxh*w>SM>ezxv?C^XGrpw5ye{(> zUw ~%dltr0Vt)juIaAF%lC)&oSpl-!gMRALE9FEr4m>3DWZpM$%2#wf2_fdK z1^sOQm?6pcAe&IWBm{b>q|MjP({DNyn|d~B%gJTSvOA;brW@%rs+ksGmgXGZ<(C`9s_E+aC@9s1e^#tJ2})u1 zbcs#eKwvaJUfAD6tj7+liV5%gxm(o~kYbtNs=8B=;)$eGX^AB~epZ}9>%LZBoEnhR zB8OL$!d-9L6(5hE#;(n)rBz*9E#IDEI_G?~u$wJK{Vi=KeLz($Y`3Sqif_nFwPNqP zxjMOl656)Ni6o?Q`?LcN~ywwBBhgGs@8m|z~ zljlOZ4m{^$ZT=Cjb1exyX|e9d;h;TJ`P~!)cI=^mnGvE_hrP$!lc?>uju|Gm;8-DN z`uy~EbpT&wVg7rKo^zRdUl{%d)M=c*iJvvNF!77;@QvOze`4aoO&4=wF za}7ptmDH#Dx3~ZgO0>^w3hNMXnS|$Q(0wAg==O$$y3>!V6uJ2t(W`Vh(ui~Mi9?=d7N77Exs~Qs|Jn078#?DU7MAD)cI^mf zH%9l_m`l_FVJd^y0&P!@`xf--mztqZ;tas67Vcp!XBGf5v_by-jcW6a_|g^WRlf6$ zfBOROnH2u*BBWy^4dMBX_BB291nT|ctMlXj8!c#+>usJ6;!o;rwzn~he+XiE1;i4X z*p9qLYwd4rdoo_9LHYTym#;(?`2jZ~fY&iBJ?DJPw~CVv*#A0p}J}H&D}NK%T%+jRI{u|v;4>rpceR4MQ7$zSp$;hsKOO?`1o;|Wa+OB zU3K0MN5cY^?CgNLfHqbSUpz*e?0|&&TJh}9I_BAs7ajAbs=CR9uS`Ha=sGvIdb2K7 zw)fM^#5F+G&DnH3P5304+sw3Fj!|U$hF$ZkLMxxg%KXy_JsUf7DQ<09o-?Pv|V3B=We5HKMd^cbN$-g=I((7Z}Bid6!K0&NH z7kw@f>S2+6gncMsypf9e3|D=WHcdB~J8L>Oe0GHXkocT+Qf#_xw!C}A38#>K!h9>> zIuKe@CpS86H<30SHrYGV#=fm}E_E{a4ESWivmH*GZgN0uHWy%QzKC^x)#shW#DGKg zDe=|v_3#b$VR%o69-KGAsp2-5K7k^7Da<_liZ3JN%ck-s$tHKFMCXDJgKs7*I~+TF z1)LpB2l6W%o{fJ7?8tk0@lL|k!jgAlWnmM+jl;3QVZleiD!@;`vBOlrdc$iMd>Dfv zfGhDW6GvG@JVnHUA%v$ywnaRLZAbG&hH^sSAS4j8EPY`mx=I9d_;u`X7-ZilxO=z_ zI51i(;-U-APuP9fTXE(}%n-OIA6Xv-7+1JV#C8}FwD-zDct)C(mul(+>WfvPn8WeG z7Qh&_>^L zG~#2bFItI-0@u^o)Y;dm+8NPl)0y6R;DhYT;FIX<4U;cwPRT*2fnW`@j(v*Y0&fOS z2&)d?0OJaa4Ic$R0aF1}0q+efGv1j7rv^vf=|Tm2ip+*kj$jLOjt~hG1_psr%RcZLsc7;b1#Vu+AFxKqCUgwPCQp5#UvB2DgI+t3iNe@s3NK1UU#E`x; z9aaanCyNse+1I4RI}xhl-Rlqg*f}aFdH5TBa-K;SNaHHc%BI^rx0fL}r=;eHowvVB zx(}Ehie&ax6e;adq0lH(SV~ncRg~-C2L>2^W@4-j1JqP!;SZj#_TpX2Wsw1IPQB6RH4!V z9a-IgZ%|nL{nzIlG=LduhhfY^8Qn93Y!b8eeobfh!7I;0M1p<0p5n zX7$Z9V->r!Mx^86TGgj#bv;<6k>nxCpo4C7LafwS0~>T&5A)3Am*9;A6#H)WCuaol z?BDkrq%%(rfMF*-#B>K$zya_<%Iv5V+9_{eo{6i0znq(vo(2n!_ z{Km6P{NxK_5!1i_^efMg2+g22r%2B|j1Tq3HD`U06n&oDy~q^-EFDVujc3#SxSzo& zCREwK7?4{Hck?+uR2oD){M3wfX=+a0P!MSPaiJlwb(X4-r2+A*1?^JpW?{{(96z^G zytl<7J1f3cWzwQndx-b*D_Wmk(RK-9`~wM36ah5=p4)>2ij*!_fGU*u^&JS?cbQX} z#jLO{?#rq-p&LuZJcem9mStF9=zmIE79POH)VuCv8xIRp= zIjVLH&wmP^A4_upN;j;MZ=VZG6);^!wWCPPQ5JHMXayt{e^ZXz{R?>-DmY~MV&d)i zi1Z=xcJJ|%q$gHB-cM$s(nAW#`_Do-hsmKCbcLDY1S<8ZBTYXp?O@9C`*J8Pi+q=H z?n}TBT9v3fPA{1$e*BlVET=bog0Pow@n@6uo3>)o>*RU#@6rFl*>W&hpIv zy5TT)K#MucT@zL9944Z6N@td;4|O>&n2ZJZdm^mwy`d$mdP75gz^SabRZUg5y);5y-nX%l@O#^;E$Cv(~8MIZIQmJK{F4OX{Op8|oax@@2YCT`u6zw1ZyHF^$a7+T>-q zym6_|iFOjUNai0O@cq;b<^a0azq;*$e?~ma)28p8W@(=bM*FWwIc(6}=n3*P5D7L= zM>#I%k0>{aabI2ly(t=>`t29|PO`Y8C6d*?gspK;`Z?zyLOAXQJaubfsI^92$-Z*B zG8b6vxzh?NMoQH(?Wg{!4e-F6Ha!1zdDbmc)q0S3eB8>~0=ix6e%x9M;+{x-bNV2*V88Ey z4yNr+BprvVxF)3W4BG;_qkFS<-;<1gwVN8Dc@EiPxgvN|3&`Y3>(gBbqj_%K0)k|9 zKWy=1nEgrA#W5JO|9ft#0}>+~_;fRUvII4dXfWY3d*mt_^&O2**5bZ5p%@cM2XS8S z8}!)2=MziZXJJ>mIRb!IpuEHrm3-Ii1&V%we$S{*p%Z+*tL66a#f3`3h$c!&nHVenypfSN9so3MeTlC0)HQ`@sxrLVk?3J9F7QOWQDBm1M`z zKUjR7O2zK1dt9G9p$0ji%CrqvARhknAm8og`Xq`nCQ*oXC%V;+@sac1g0bmGSW_ac z-F$57@0pi~N!;4rHJ_BGfOE%}9H}u^rYlk4=tGLrfy5v`zpG`nlUV_yDE|N!x#YO@ zTZB{@!}HJky#Z|n?hV@a(1KTOS4r2rD{p0-XPP3}FQyLw5z7aL+~<^RS%_C!SxW;e-E=kh`5QYX zOIL|E6a0i3S+bdg$+fW?GdQcQDGjQQP6XLl_!@mJDtDqjm)Gu$vclfSplaVGQl@s6 z!Q5w~t~%Ox@cC*5G?~uFodirD8PL(K3~MtqdXvw<&vdd%06MQMIp6rWYH95MWo4EU zc()u@46(kdapsQPs?%#c+uqp3*GGSBcY)?{Zdg}+O@nn5ECHfKVd!$z^piKwq&6r{h>lF_DO%)Q>`9=hV zc-34@_+B8qDMQSDLnnMPv0s}u6&fIv-Yd9i!A^!1Y8G4IJ)4OXkbuQqH~i4vOH+er zP4R@!g#Ol=ucvIGdl;c+Vr(nys$sF%T*+9CeFaQIbg??94wq%sf0ID**06%!i)-ne zd*jZ0jse7*DarLvZ{}JzQ37IZ?P?I!nfukctb%?4Z|4CwC#f43U!rusk}++$cHQrJ z7Ik>x3B_J(H>_3gAN9Ps6@h+RBf^%y>_#^(M>@wOSeh<9#V4?pPVkuQ?i(!joT#-= z|9x(Yp15H5I~a_ zZ1nP9a%(7AlykC`j!x1}*9xAj(>A&##%o3TEabaVffojKWV+ zsfo&g8?$Gwo>JbAv491D*MQce=)g*N*uO;Lf}eW&vt#BQ=e-(h2-=w17-{IIur9D> zFj_vhotFBj9N0-%kc?5R=%B6M1Ge{>B#F-jn;1ek3?~)BDU1;8dIf}{oIwAr_@lme zDNJ+c>lFNArw!cM`b7J6#ZYdIs?&-5u^1tlgl2}%`D`;bm2E6R@o(4TV9aT*nk6=U z8y^6xb6aZK9oIlC=+Si@Td5IptCSjm5_mV4j)#JzS_H`2s3gFbs5RRScG z$1_RKlt?#oOc!n%pU^rUt?OE8JLnTd|5| zHBELW)%-MV686=_ihNj2>jZKYAoN4l+uFHMK!#jkO%u6Bk1!Xj3GCIU9PE0&aOHZm z;B2&fqa_Qj*4rC)wYEudiQ{uK2)j`q?Nu+aRJef(P!(+=Br+i`^g-as`!*0f#Q(;Y}+g?&R zs4k2%mw>i@r46B`axml};j+n3$t1Q#_LS)iyIUEI*+B3titMnMW4%i6lESz6C&`X! z94FepMHgzUyBF(4xu-+xS!Myb-&}ZrruFXpc>qF>b>Z9dBfMlgFuAckT%+Dsr%jPX z%0-U6^2tt3hT26o_1R_bcH*(_s`KuhOZ?kdj=a_m-gU>Dx&P7Gcr176Cfu~^0xJ{g zY&KK>XE@%Kt^!m?c|KwL6!GaNE;9My0bV$*59NBvJw-U zM=9&}snvaa!S?&uRRPIlp|V@HP;0+OFU4>t8mZGYvG^$F2MwzU^bCHZS7HGt4nb9S z*m0YW?ObUZy`BRS@S|~DZMbPio1;B1I!*O(AV*Zrjb6_tmGUk?>YJR6^^5vz*vZ>t zPQo%IJ>3M0XDm_pn{CVk- zVJ*HeHFkdofr##LH(8Hv{8_V?B4y&)ZNeEQp{2QYIbAmKz-S)0dfNQ38m)g)(PjG) z35z+@TDU^oniw4FNS;+-#9)>Yv!n70TEQ)=+CFAAeTS&W7U&%K=yaarPKUl9Y;;U^GG;ZoJE6G+KFg;txX?0ZRRo z?@qd5=%ELr|AiLDU}i9va+YrER2PGmN8gYdf>`x5ed+ap0c!`QRTH`geFYzURZDf% z=U&^fetZ9ljhKk^fW@&T4NSuZGb7ku+tL0joEAD#X7ST;YmAJ**CA^R2I0q_OG%_v z3dTkhy|#n>!ykl84W%1!ZH!xtmSa=bB{s^xZ0H7?ZG=%=@jQqOZ;Doc+BIqC=U)!* z9oGw%Z+rH~vOCJO6_oR!5_F`v=H`_VCyI?gA__zE@Q%I>k>AdZJYg8Kqe;LdB zTt=X~A1$EzEaGOC#n<#yq@?t?TM+LdfO(IFtH6wV&NDsQzUv|u;ZkjLy&Y60QIYU^Qz{XKeT&}DJ?%%i7o1t7yh;C2qNFEwG_iKXLlb3WR?!DT!NkUH$RWG)cQB;0=;M`{Z2IQ3EkK$RdrU&;v|y-*)7FzlV& zU9u0ShHg)(3cgH$dAC$r)5bsEqaB15m`zK&CAts*^RadyA5K@~@1G!iI979Lvpiev zD30>2!OH(`q{~5I=tOPiDyJUo4Pd_oPkGLy5^wpo(uGi5sKwThA>oG5s1~%hTg9<( z$UG(A^j$rh3>0Ov91}&&>dLRdyKh^GwzuZnT*a2^1tPlQ>m9h?)7i|#YF|o(ol0!T zt>6E7JyuK!1sk&U%dLO&{JQon4Mq@TW;A@6K9=S{>rgUibQRMWI76R)xi(lJWA(jb zL%%5#`f1nbya&2}mwb;Jl})~Lfh$IB8hsDAM@@JNNL>mFaV3z?4CG#aTV;3#v?wHD zYH{3&8Pp3*WS)xonlP+0aJX)J!8!d`$FmpQb^itfhu!~&M&|ESVE38mJOLtPyBS6b8-vS^5v!hHZ>S z)nmmpu5{#e4ic}^h?3Jgr5jA^-mBQZ@h+V=NzskjW&!Rj#BnX8y|3-))?Xj8k6 zt7707fgHPxSsfY@a*iyrt`D0=U7Tn$tXXN(W}tQ&+2!J zdXQe}WYg2`3;S{JBt3CQ4?TcDC%bkLqs|@jrBCfoS8=YWsCs|?{5!Y-}m z1^wSO#o0uvHU=p%JqCm(&{U3OX<=X@GX*&i7xqNP;`YENCjyRka$pbM=rhs^ff$_-M>^ub}LI+wd!wERa^}96$p= zzUX+vG6`diTfyIe`Jbed2-<%9kOy5#MJ`+^CvnDh)U|aWM(8@vzN^d$Ye166=Imeiy{n zpg<~xOV-I+u+W>={yP3n?tN;j{jhYpYkyHlV6eMsAN9Nuz|8va+|uK|222~N?9N7> z>O1U0#~}AwX2fe)t0d=YwgrStpxo)R1dD0enQv0GCTzHv5j>v2Nk~+%@c@B_Ee3*i9Rq@iZR$X;JGDuXg?LLJ3~minQzmW`iUm=JL!!dtMPmsvs4&mA{giX z9$mZ>J|GH;drZm4YO0(vQz24@;hgz@>#G?GJoxoiSg*2%==4# z$_$%J8?VAY4EZrT8UI&Ej*fL;h7@D?P=|vpg)=boTwe6JY-4zMlXH4a*M6Q&Au$_nax zwsRG->%FJ0NJz8ErGQeo?WrY2OPG1@cyGf+3&)av8zDUegrgJPUT&6ovgZ?o9iK&i!%ZCo7mQq|2w@AOEfl(nTrq%8W?#Vw-(i_o{5Q>p@qPmPm;%c7akL!N$CJ1ez)-@s?)6dm-8sR zdC_Q(&3+}|c=obny~*r}cDp!SFC~Qj=3%9H1F)JLY68DgLEGWp&9R-9NGz)F<)J=l zQV}|q#L}NyRaI878R*ICQ*)x{|7PV_-TrWQt`7{ubeYZxq8_y@QnGfKhWOY|e}}*Y zooo)$9QU-yJfov79IMu*+~QSOdCeaB4fV6Ed?0>!4NXVS{x@0PAMcVbk2j3}@LWge zGlIq37&li#m=zC&q?2X-=HByypV@&~9|0B%ToZY^us)=Rx-btHcnN~UE{p^*JAQAz z=Gs|1-vS@+CNDUbjSg#RcxPaK9RqElE+@BE0Uf%hTF?#RZaod^fa!Bq)RREfi>y&Pl&n-13ejL;rqSvU;*H(Q}R*H18 zP^e@lU&4K78LSVt9%&r)GZFQ=)DQ|EwzxH}NbFm1xs1RE&-0-IVV0F3oE;$qxJPAne%^J zKkz2{9%QFOL8;g#wOUzFKGMWnBa_PuR;u>w z?kSz^7hUaz=nl;+|FE;7ElUTAB- z%MmP^E>&SkD_{E?&J)c)5?Wx{r$4^5+-$)em+w2=|F7@sls){=j@E8JbRg(PHq$~`(N8dD;E z_op7{Hn@C5W567mTEjU{7IAZC8I{LTL(dcySn8kQ<*36YmR89plV=^)`_(}tx}<0Q zhdGSb5>J}^fRWmmGU_T|?Q4yrXxZQ8AU}A6-@eV({;Ha0BAjWPF1d&~59V8q337w% zPvNR{D&W-a!;8U;%2TivHnZ=T*N_{}XRFv$iqA2mRI!fNqjI6hzmoXSN0GuI2&ew! zsQ>mQh1TXecZnwV-TAsB0(4t>ODEj8ds>+d`da#7bue?Gi_s-o}M8ZeQ#@xZ7 zJ|wniqXgg#HnDZum7AEKPQ<-XuU8N;Bs%9@> zYDSzfhtCmRwgbIwetja4i*%{R)>o4$yh7+I>rv9cu6O#E*7TW$B(bcBsc6|%TRc!G zoQdXM@z*CYJb4CMFF`v0^HzU*S)6}_rhM_ZSgpDCS}geIJvlAJ=y-9A_b6(~u7loA zjqJqoT8_cDV5upM&)rBtCqNdE9r}HB(Ehio*2p0b9CFSoYz0_#ji5i(xXtpzk#-q_ z3#WoLZcN9SrDzwEc2}r!bARxO7i^TPO&y1%-OqF!DHbf0t1Y$1dm#8$!ns{j_Kr?M zN%EIG{!FC5CN8;f8JeRP{Yv?ykPNjdKSpK(S_ca(Q-inQu$}35;2}E7Kfe&=@4F$@ss4K(NfUk#Pm26#f^i>}|Uh|hRmfHNXxkyOgj8V+;Vhipq z#mEYVKMt;~Rk{7pNV%$Qav-F&-rB;-A}c5I7t%BNEA+>}cqH`)bnC=Ini`~`nSZuIad>RI#%x5|g8coR z6XNn$k+WblssI1r>Z$_T?1C&UR=gB2|sJ@81!R=UvywU$8SgSRnR zEx}TJ#e6^$J8R;IqC`cK@-ihkMHc*y6c)-|u#b;*-4=$)RthC%*{G&y=<^x&#-yg;bB0v5z{&jZ}=ndcMj776_JZ+Z4g4t1V9~de(TD>2W+h-vYRHl%O(U4%L77Lsp|0>K`Kv~ozKFV( z@qO$^jRNv&fMfz6K^az-$zH_1Yz8{ueFRpRhk~A|v`~&-^bIZ1Q9#fqY&QRDJtl#b zwWRj~Dd=C*byYa9BMlBVuxkgJ?YBn@GH>KRZh5Wee1s+`1i4Wt4+N^Ra(a!cf|8Pg z77^(~Y44nXb^TYWpX4}L;`j@9iM1YUlJ5p9=#>(w6){tEa^e}W2?$f?&xZ2eD@^sj ziCLlzMI^fh(O0!^tcr=|r=njmE73?Kt&+**J#1qm(@m(BZ6=4TD@40!7Kek5ufuD4 zC0WcVm6J2U$^5Kd;c=3Kq1g&aL7iK2&hm>>R8ngpVV=FY--PlB9h|%UA(9)XO?>sq zVeZa+2@G-QT8+Mbn&3Yz9_yF4N%9(9%c1JH#0z=oEHbt|R_~hAS@FwUKW1U7(L=)UBHVfG zU_K3!ACNCN)Tbp+YY&8qb;D7+$?=cEcX3eEgGOcZdp@V9Q33>uZMm|P!Fsx_ZfC0* z-9~<QQ#KaLK1*xYi z`%GC*^4r2i$A5bh$f_}axk#0bq`)*C`~{(mpbwqmV>fZ?@12zfXt2gpWS$Ab(h#GH zzo68*7#>8Z*W}u7N95NQ*>7TE+hp-3ZhD4E+HteQ<_q)`Rz>vWhe($&C2k^q&Cfj> z3?&iy8fz&efFSb2AL)A_;%D;tZyWD90hj4PV9DJ=;ZL`@Slu+yJ>O1|Xvh+hd}T8n zZ){(_2|g9BQtz&PQ*jWUof~S3``UMvLbI^{IH4_OB=tf#JGUh{Sj6ig~YvQn9DWfJS>+& zJNZGmH;rz(N0-2OZ^f8UvF^Pu>pL)VC|VZJFw-Y35;n$I{4WflsIp&UQNNTGK|M{NiB5h7|(({Cfu}p8qh{- z6?#ex345c{O(~`4!ue?t23!w2mES`eYnt>u)UIErZKba*n`r)EBGuZA?}*+=JwWNvJU~ zSI1Uu4K&aDWw%i^0TVvIi@*_cwoO7=8CMbF76Me$BmQiMvv7x$H#o|m=<>!d3dqB< zoGGF!`85kxO{8WbUHcMh5`9q}*}c82;Q+XeOmb%N&neO}UprV7nqc)SP z8GF_Geurn$kZ{@2hS60IA-q&j*i~r+tn?R&# z^=0~5WA4S%*Z+g!a^-jKGU`8v>3WNQ&_a^B?=^xo_a2CUts0L|f1VV4R`L=p**hAD zNVy%drl(ueo84DV^>LnOYVx}0Q1W8M!rWV^T(rsgH(KHcwwfwjyf)Lc9M;*Uc*QV& z@>4|U*z=qE@DhbCA>@xVym#SrVKLCJkixchbrp7CcQ5bnO!AZoY};gA{jL>5{VL&i zPZ5d`b}<=5!G|asmLmuF^gw|qXh1&h{k1Hj?-gm5?@De}7c zJpzI|)&D62=l!n?JVx8cQE$do;;#KKmChMtYG`t3jLI`nDL&c`D)90pvF2mdR=*82 z^~YOZZG$%7)G39OID0Y_0L(4tMWEmRvsdqVtd(MYt8TvSo7J5`N_k#xm|YrBj2mJg#Za} zyI$KP&7A#bc(0(>{VgiJ{f9ZaEB3Eav>8;byx6o=4i&U5=&?J)0l($zN$cM(zFRz| zJ49_qLC0;!qh8FUK1Bb}zVPXq@Lb@WLIa}@?)dJ=?s)eWU2}@{Z|C2A43PYU-1H7!myCIjaR2Te z=eIqHH){P`8~sn`6^*` zVv9~H4V@w3sMB|1JjutcVXPumA&{Kgd`j@Vw7zqno!YoCeA_v@73Z;av~77zVu>%b z1x-M?Gyz<(S!9jmlx=9g+Qrkb@5`NwW_wWjwL&CLVk`i079t5OmnN^&SlcO=?j3iO zaeH2O9#3ZHL6onfqz`55Q`t}OxebqXo}6Q?Yh=CR+hQBf>qiJ(PjS>ZK#Np=9ALps zBKqdr!IK|xjULH1RKs`v(w~5oA*A)lxu$Y}xv!^G=leur!n9Tt3%^yb;}l5q=n~O| zx1gLs1LG1~6TsgrqQuG5`9+_6h`BkfSj9FcWW@dv7w7yO3Yy*Mc%;8kSDqwfktO|I zm&lR37SH!J?c>b8+h@sewQL78^9&R$Nt_{(VwxS}uSe~*?U9u6^%3UuSX1D9T;YQT zs^p)@Vr*7{9h(hf3N48ovN|fA%vKc7srl$WhjzwlnKp$;{VJ(JgYe|M=x^YKPjHPeXJ z3d+}t`bEaZc_`8a@O(Q#KiI>^5cnk^o-}Rc?+tri@;_JH1-CYz#PtX0^{8_5!Y_x0AgYwyZ>#m9&Q-QV!f5aG7@23YqtJQlaU;L&L9BKmze z+T*47&3Yye&RN1I$X+jXC{C-Xy%{{H-u;QTm``#j^wDjZ8k(3Z_Vr?5CJ&|mIkp44 zJ=cG)r0d0h>?~T^66hyOpdU-w1&$KvAK$!EK7}?OX6pqgp;8OJdyEOAk3|gdFe7KO zD`i#XKAS7Rsa~3ot6fG;d5(VPFR^2gJYC(Q?|S#8Keo6HaS{9LMENP|*}yPINiL2- zzv#H@dpe)}kXP~GhVeEMQQfLRZKTUwgV~FU%9GZh-{hTsSWC^m4Kyy1!a3u%f+o_$ z@{@HDTZpPOd35=9bF*}%EBjMST<_URa^hKfA01Qx=I_g>W+&_Dbns_0~v^8Ut znYR)&_jEo`Nd~=oSN`=jy;pFy6JR?G(l?f6eWvo8M(e~n(D}BTJ zxA3=Z4x5%F^j`00=sndt6S^lg%{kqa$WXl_;nV7cwyAWL0O8F=BP{~_$58$?)Agz8IoNPxD1`|GsamqC10OZ zTG=ppw3=PJtIanwhakx~H3Gy(5N6DHaj_twaVW%pKR$u?vz ziN|%3RZn~4IEQXZzd{^Vb*`|Xgz3^+&JCC4SD)oG)KTitm8@u!9Q~EKaSO*aj&k!{ zdy=7IJw#em8=-LYg8`NAe(@tQs+Q|M5Ru@bwNIhVUbRhzegWccof(9;M*S2s%+lhIP6!Oa#6VM4^ z%bp6IXP+yXaoe9rlN|Lmwf(3q*z1SQ#PHa%Yq0FGX1}8B$7`Qb zo)bZzA(rp1q@F%3JAIN9y)0sMCXd_kgjq6*Pv=j_6NE%PjNU_+-%A}ye{CMOu=MfL zT9^Kmmb=<_`tBiRIVS4$vhz5hFLGJreCqLiu$f?_U4u&VyCtkZwIsun|Y2zxc=**-Nq2k8l)^763R-+5uP zrM!Fnb6>9=aSR6jto`s&iP(`)wOUjOo1UnOl$=0I>Bx_v!e!_FuE>0iZ1p{-M}Hpm zCxv*Nt2E>woj4}aj9Uk_eXAZiC9)cnc43JyY5XBUy+1qU`_Ou+e3B+yfx#H5!9P`Urol!Sz zaU>nif@bx0v~s5vx?RobHK9xEo`qKcM$HAe7s@mikybg(^#pS!u@*naU}==lBp*;d z=-^0&akTt<&B!m_G=B9U&^A$0?{2`x^h?Kv8S zZjsOxA5e#!m1u}q!crs-J~;A3<96}kkN)Dhzw6|mcX6j@WOB;bwNRAm~O5H`k9D?pO5N~ z?}&q7=B*pwa4yAeH4IHfZ?@g5KLRU{$pL@(!Z_TfYISkatEPWB#hwc=nUVCa{C7l-NgdMrQ>*XC3rJ>zUTf1I(6W%S)O;uw#uGkC|4Tso7Dw zQggpp8v9Q_rw%jgtC7vJ4=wG@D@~hEbwDtkhot7MtW@|kJ+*m2Vy091kRJ4uVT*7D z1T5%bwv_^AsOR!J0C=08|6{o~#$OBM2w14ozQf|g} zF13GbC^0_IYqDq;O*Qk>FRLv}F6m1N#-27q>CU}psCd#Kb@(8mHc;@I45pX0v{EE%PF=mE`M=L4-wZ|U@q{6vXLtkspZGgxOm@xF^F(d z8rM{p|SG2#vGtKUMD=))CZYrp~+~z+@c(5MU-f$hsd*2#qogu7OMPO^Yn0X2q>X zcUY57qmyP}a`|&;ItC{xj1Z-)m-4K?tO6nWhZXcXOFd}Q$yp+*Uwu=*xrSjB@gNK0 z%Nily9)nXj)w{C)79~vJXV$R#Ja}JzLM?<8E&R%_@cD#TWEY!P~r{UGy9I4;)2^Cc@Bz1epM}|gL*NjgYUwIMKldXpq6Td`UU!zG%<%sWmtPT_+P<>?5 z7_=z!u3pDXw#BHdWEINm2PLL7$gxtZF=^Gyn~{}3!CsVV<>60d(Hi9kTcAXKtoDAj zfT`r0(tbejz%f`~SgAYF_3-z0s(&v^Q;e(hM-9aS|8&at*ox3C*uRX;<|Q z`*r=tX0XCdbG*9#DPNXIy^#xzO*G^&Yxzj&d%wZ?*Qe3?cQ}VQ?$5s~GmXHl0e1cS z`ij>6{ljdp2D0A2cJ+<+fB$N~?m5nB&Bk`sH|pyDSdz@&-=wekqEH;6A5jq@T#%jl z2jIU}nYwOOznf<$RMwvPJ`Ows6M*!mnA3DLD~2D%L^i2ag$rWRyx)gf*ym`DcFnW~`t*IeU9RiL=#$Bx6mc)7 z0z`aGFOPH5-NGFj)*4tCNO8bHtK5RwsMhr*TQsc_$eZJD$G}-L` zDlI-N9=?|Tpnc;se%NofCX3Z0@;>pX;d=A#UrnAmrd>5Av#1Mmg4Lhw+3GIH$4sx`RLH!SQmY zgE)3|q4Q4kXk%^GXI&fCSyR@O=3x-GmUQKC?rxQGd-b~ait&GMx|5s9BjA(1MHr-e z_rKet^86=p@U5VBDZ9SjUqpGmXTg=vAXV`?%gy?V4=tCKmi~oLvXEzbW?NgwT33Gj zUXDky;C%+6bSnCnxoa?}y_gM3otAyLks#WS%rPrBCih*GM=DLctQb(@E zk~zh0+xf()2Ysoi@44yDPDowRVUb#ix!Kt;-QH``5~PJtHtY31ovmbgT~Li#Zsksy zQNH^Ox_pi!`!pFLirgLh3~&vTpz-@N6dI-nwviB9QqpM zQtE^HRh}fJd+Rkm+i%fZU*hI)1*O>T5Cg~x3hZ|QLsQAIm=+8YSE#Sf#z4bim*hO= z9PUtxZOg<|mM)66uUL!Rsb}*;+L!!F3Sx?Y4Bn6vd~XT%@1dt77Gy*M3JPMf^q#fJ zb;~oN?BBt{Kg~ZZ-6y%=zfiN^(7Nu!-u-Y445TV7h`bQb;R%&GW|WDlpZ+fTnLcAY zNtMl9#G<*;Oy}@T>0}D%n0imf3f@>LN*dFc+b^-`yUw9g={N{#yNy5BpsXOKqtq!_w>`2@52;)#R6$^vDI_VtJuuNogYW1So+oh$ljG|%!Nl=;R zSFcp#UPd+;Cq?G}CKnLk%@1;4x+yA%NmBgdNz2lkW@f*6$G_k8t^>#j%3>GkFP2o< ztxoZSF7-F&)3TEc@cc@e;AeM5Zj>-U|}uDHm9KAv;e(bd&Ic%5R~c}>G{)) zR9C2JIPjIqN|?J5|3&T48-2D_wd&%dKN5*oTb>=K@;{)XS+iF39eR(Qnm5 zZC)3Wq_;A5sTxU$X@*C1_jjdOS+lSPcOUnMG>?nc9gmbm zIyR`ArRP=Jq{*b~QvI4dO?3{xi<^lxOOsTIDi8?sWK#(#uTI1|to|Y6UFeqrPOAM? z&xj-LM}avlX+aqDK|`E+qOfHtyn!nWB0uBR9Yph*xUzvq1Dy+GGTEHxXOxu8_XvxC=bnQysW54!mT921WUg;A^& z{ZgHSy$uTsvh%U^)4NnmL8+-NVTV6~EKAL%Epxw7p6_E%+@dpwuotym!4pE=Lw|FKwe^^4m4xIn_kZpF0?-)u}+ei>wnFvy7>< z1zXx-6Nu=YYH;oJ4jw~IAO)EA?86>?_AWo^WXOi11wpHjR7XLhgo-1JAJ{;=2mJ952pxf34=SsxS00qrWDkvdD{h@@D2hpQf5}X;0Goq+#Fg z{p}?2{&8on4gO2JP&O0h4ze?SvU|KFwM!pS$)~t>lAi+SvKdpQQ97UgX5LyD3JDv1 z!)Gc)CI{~$rxvrywugyBA*av|aTIV46^UJhV4AWsHb19(WL1vr;atAjjC{*^;|*EU z^Ii6qqClzh&oX@;tLd$q&ZokdmpR3|<#!klrBpP*dTc(=H``$s=FPG*1@myKM!Ovh zAwSA>%;fif|Qt0M|6=)PtY~5$~>N(Fgu1i@@BsCvzBh6)BwM-XLt(~)$ zXm}oa8vMb1290q{*5w!3uLG>dW8uMD%*OK&_wWK>BU?~Vbehj*2kNQXmQ_&^`^qnF z%;A?PK__;De?v0BP-{_Gbh>BfSsNdum&GpjJuns1g1_j&@K==#QHQyN2ZyYR*g&iI z0Qs*(F&WQ80fP;n(CYAZy~L?nb+Ar7@T0{kjQDDP z$WQNA!p$E(to;G4AI|a1L`6lXyWdI2lS-ZjCANo7ZkVMJg}DN#goe!0@{1@7MMsId zM1Lh@Gm5$5NtJx|lCBP~$iMWoHz*LRo0mLQm{ON29xWO%CL-EVP!W^;-og`OX9~^9 zZpoUngc8|q2EM(O_Jf^ubJ1Bva$WfWsWP#J*Z{1SzL{C1 z7rZ2&xeqRR>cU0W15$Vd31AwtEH&*fUQg%onSM09LiBUGa6KqFa*x&dx$Z((oy3dJ zcHH2R8mhR(G^giacqN{9A25y8h#NPN9>8WK0kBt8S^46j!xJ7tzB`#YsjhNPNRbXx z0mIRQEfM7ovOy8IkM@Xo?HV|{B@wkmkyjijEa3?L@>h$4<(xZ6Ysl~E?8jpWQHcVM zG;i9?G5putUy*A320Vj$rLhxUe*xob`3eQqK`;~F4a3W2IF>?-O5}CLEjU^Sece0{e;5?L$s+Ej_1z%XTmkxS)2|j1AcFcm zUp_t?RP|127VaFLeC$u9T613eAN)y`!Fe&l=i>9?u*f%iilXrhw)GczGYFoP zZ;M9X;P0^OaQSQ7t}_90a)wa*-)j7%u zXwXwxeINNT{ewmk`!fh;eVf2yz2rg!kNdD_AhH+q_Kynz=eI0av=QZ!(C|$Eu|(;3 zEH~Sp8;2*em@6;6rK|+pJdXQM5QoOWxNIh57ENuzH+g(9`>?M+s&k^#>})8D$VW-~ z;OC(r{|Zy8M9HnNE|pI2$I#s+HU(%zTG{!AwIhzS9*Bgo0JTDIx6UqjJ4!qVkF9}U z3QiPC&$*`-y5%lYYDPUkhu$N5-n|U530wS2p+vPutP2XMwXv?0g-G8md*QH& zilj;eg-M#Cg*RsANqN@!mXqGH&xo)(E^0`mvRKwjx-QYLsV&e4KEjkMjKZ|cQv5ex z!~P&~YIR(_e5IXxszeL#bgOrVAMB?m@hIuc3f+;cE+S8K&z(*KHr^n%HUG z0aPiEus9OfU)wFrkka|MR&bM480II>8_+-x^EIV$bR)HC3ilYo&)ulFIM5YtS& zwfT49k@nDJA}-qoLbEl9l}QFex+Y_4`MT2QGZ5v9!q3^tZYjq4=dOZ)Q>gBtmH;V_ zf3q!PUFCE4)pR~y9(?4vX~`Zr1lT4eDPD*JyiYX*$OYW7@xl$;jp1C(3;JWt<$|r@ zpjY$wqbA~GvU9x|-|&6ZTdYyEHYK7CQ`WtEL%OB7IO1WQmz~9d*$C2l3;eYUGVKhZ zoO8bKR=rHSPX1q%V#sv36AYX0pRcErrY-Poga&p-y}=pR>tw&;^O`SY=oh(DZu0%s zGs4|S284OU`3%3M8QU_nhq&f3HCXk3`r#BRq9Y6$4+%M@nUfiy=A81U8L{96=q`k| zDcTg)rYn)t_}R=^CFcTwT9TClx6C^SgF-)C!r$8Y;LIGr`#)A^;Vs|QoQ%o-`c|Cf zqoQ8u5`VO~RCNu+Xci`3;sX-1-iIwy*jdP{X0EbrA`rPblV6aY@y0vA_Za`!R@*(n z&9e7XVO=cZ_MwTNYT{yjKGD^EOjJvT8}k@sWZgn-WyCKz|4lonN9Tpc!R;|~lCKbP zOB=Gb{m@sdnmTZ8_GSstOOPYX!6Z#5%pDtZ%wU7F70g%yLD;PgrNjR>GXDpu;b7oB zVNGVan7)J)4!wJ397!+jkJ=~=&ZUH~Vnr8E?udTd4GHwyM)BkV%A8ANg@qm(=i8b! zkMJUoFj%yO7^Jza%5@VfV?2^Z5r`MoRGrftCE^}ERByy}HLu+GvTHx29z^Ip@Qtu8 zj16&QLR6Vv+z6pg8$!cDxlfvuR;=X4P?OjxOJ)l42%ntJ!}9?_g|QQW)eo7p_(g;( zBtve;jCb!J!9+|lh{8O)7(DX)6D%eWP@&9ozL_^ebU)5?ik*>fHrO z1#uUf?>4?B=3nJDX~}=J;bMARJp#EOvGzy#QfuO(q%-K6Vi?^6Soq+4;y&``n9e8J zM)WjSXy!g%g#_}!cZ0ZD`cXSZ#yty%WXRcfZbWB}y>qRJv>1>S#k;MXRnHbBb1pFn(!d59Tan>ZHnSk-pU zKCo>}OCZrM@g|=mr!KJ0G{@F=Lzps`r2;hI?Yn`Wrc%Ss1Y4>vB%0FdQI1WrD7{(t zD4hyCjW%c1?&Qm6k|yieM#53yrK*lTo*JctoA)rFKZ}=*N*^>D2i_O}#WKUg?!nUt zNoAH9tbp8(c$oBMr*r{EKb=oBwa|r)?Hu~#qBo_UtTvsG^?aXrwlK7o?`Kx-jG=Nt zdb2->&|yly^biI%)cr-dp$&JY0VBpZR%`d9+1nK2=I__4(^ueJuX#3!h`E2sy9-Wb z{fGCO$E18bxr0gA%rG7Y(;e8(k*ZYVDx=MiJCn=;=C z0x+k&yIb6xx>$@K^Sj=IA8(y5X@bI#J5-lu5dKVc^OI+Bsz9*(4W?~_>7oXAL5SYTB&+v6oF*T@Hx>_ z{;MO#7>v!HdB9-OpB5+*&fsC+pA=Fa8RJ1TBU_rv>W)c1pS4M+qBym?sZ4EuiNi&P ziL6{UBeK1wTSf@K>wPl(HdPOMBUXwP^j*h}8^`^^eeT7thALLVvpOBPd|z|~9Qqd5F=EcR zfYU_yoBZY>nz8md_3l^t*FW*Zl!vLT7&r9MY=f0#@FI;qPJ5 zoZ_Z$TL-=7pQLroo#V@1YL59fTvDBrzsPvAkCH&8W7YPHpQZ7nFY)%8uF^fiDM$9G z1)q-=Lsjl0*P4!-oIcx;PGvc<83{5DUgcbg6%;F>7IMWYk#A#$s1RQz=cC&Zk024& zrqJoRPl}097LeaqDf<=HWwe6}$C-g~v>Ja%e9{M4Zk@ZW=7RByuvgLt$!9N77huF> zqC;f$`BX_-Q1O>_iCVC0<(}`*cs%8`8LfnKV$Ytfh5RK06<2U`xrqd*Bzn3*RG#E; z3KZczmZKNnKX;A^rzUR{O~fUtWAOA6_~~wtz8`d1&Yp96O!27UToH~Q^oss+HujW0 z8V>^qta4LRPL z6eTG^EgoTH+vO76ZfM^hLsv^%WSHJn?=TkuJ@EXeZs4T%e6}BTXq}8I0Po(uB`I+u z?)IGIxLTYpq#7221f`L=MH`capquBjOr$kzxAk=7Vyw9&LeS0fGk8*;_1w&)OGPO_ z5a!bk7P{|nS!&Ax-7qV`GbAp3ko09E!-hwV-g0oymKxGPQbJ@o`Zm^i&$T1X47@YZ zLsDXIyNf?(;NW-hW@}!ho2(qCf_RM6w3WN}v5cf-Gx-ngj8#|BhzS{qAc>boE=5iq zoS5B8K#-M4y53@|?VB$p^YEEaV*q3;b$Qh0)T0HhAfL=Hc`ceAek=t_Uz>igkzFxY z{1%x}Zvnqin-skyCa9to%W%D^FzXULd^RX61{3*d_O?t&_7E1WVSoCET+wk6xL=)Kp(1i@`P^o2atYL$CbxviJ$I}luo7QmTx1aNgUpk^vPVC zp&ZRC#X@-0G%qk+4DBZsn@M^4^~`8EQf$w>@a-TqSny{kz$WSc{sP!=Ggl zTX-`ow!J6Cx0&VDqX@6JbZ0Nf_6DDmftim?aumYcaC@P>vZ|6&wH^Ed>zc4{#pw?*=zK-&?V!HD zPhAEt^m7UWd^qQ#DeiGN2P5AYYLhF-cY8KtT@CWlNB6sl*o=va1`T_-Mw*%`|Fa61lS*Ri9yt@Z zT@d#dD@kTdB%ETJd>CFBqTw-c>)2L~R10vk`of694R#taLhE!4A93zTLuHnivYv{> zWivyCFL8BQ5?B6Pwhmt*{qubwzPdH zy0r*vW7mYFD+S3R8o3y}_X%71?FU!OU!}y&a3M_(710{nEf*B8j!pzFLR35vQcnYZ z_@&mOm*R8_vWrWVWXv**o?QO8ibl9g0Htngn2Ts%U2>tY(*7sT0p29~rx63?#61cZ zq`#N%`N4Oc+Ywb(H7Gzoc?hP7wh&-_ND0bcy>UVK>qvxi zi8Q7fAYA{O%!g!Hu>(lg3Xr;8Y^1rnpd~1gR1oHl=k|tr|2W5c9Q*-!+50T79(MaP zPa;aIpD;H5$6Ooi2L5RID{QK9kg=jM?$N>!2Q0BH8|d%F1TR(}PyMWD{@+eb={;ow zqnA8VYc-0vDTwCKY<3HX+ z*c-gb_9Xvk1-{6o}O`63t!AHiJ>tl6i2*|i~(;Zs)$NRl}Ou!)~0_yUYFnzZ;)_L{%h6CHBcKY z_B5(pdvo5V*G(b%Sd>tGyT7AM^6cWK2zc5D$L z64d?IcGFGS>Eb;EU(lHhM>Vk&j-v3iy991sV!@IzSlK&R8B>{6_Yqm-JBed(R2s-L z{RjTN0iH(ZjJLgddFMP1SK|LE5y#ua3t>wF%TP)D+>bH$!Dwt|Vx1R6GEJtzuG`2% z7YwdepBX*5lP}mz=ym5IpOu{^WbcC9!8{sy01D6`&XY1sbpWN`J+0DvK+Bvf2QKL0 zKgj43v8aU%)bHYjUeK34M05@k0}Wj;RIW%}58#SRP4wvT23Jv&WBJJl7XAkP&?U#s zef;fD3obek)VlEs6*4Fcb8!L)Its$wg=c*MYTiRA)jWjc(syIgpEkLWkZLmPCEAQ- z_&%Vs$*2twV$+=YVS3$1cs%BfqA?9Ta=4i07(F_(3tmx6G571X$)FBg5DecZtdP?V ze_b0B6IG#K&7*iG?pI8`tPp0{2q1iTI^*2C_1oBqEB|chv zfK%`SX{T6HMw&aD6V&^`*N7-=kb8-|i+{O~LbL}XIiDlwK6`7K3jzqWV3vft>yS4i z#$+W`$1*PvpSCX6>EHbDTp?j>(yPs!vnW)dtw)#dH#7S_3?Y;^CdGCy(BTQ(M}c2J z%WtI&k8L3i+K{TJZYQ|O>1`zz6%Wcp8=DuhxZM~xg zW_kSfpR-b^$S#<(OrvOS*zUCXgBW_|t-$aqu?%z6O#AJaS& zU9pZ`2-xlS+6p*D+Ai6O$WQsJfJSH=ougTOZ}^k*;P4QNL%tJv;>%FLMgi(!iB0qi zb743e4+50$y-Pc*Z!i7~R~^H%Oqa}_E=BqGVVJW?%}buDso89%I0s&~IP#N`zKTZ7 zB2f7FZY%lmc>8E`ToIw(9WQn~&TkPo5C8o?Ka}Gwa+<@P`Thv1Yr(3>X=l+mB-$!;f{lnQ~FP#dKE8l#d_F_eu#}@Mt4YJ+j3&ELRoi;^SyJUTJ z+%UYw<5W#ajoy=iIqt08^3oS8>7wwa844-o2F*rnYWxwPAcoMw<5+oEGzMj^=;%J= z=d5FN8IH)Add{1X4U1USeX6b0jGrdtnS-8v!fJ3#X-Y~480weFI&zO;h&IKQxZ?DP zTR;(&(O(=-1N_H#o^3?VdA?gg{}Yr)wklmbz%2E~TnY=HD__e6|I-l6&k{hU6SIf8{OEq6quqhiC?^+g889p=|q;cExnkH zc_|m?WFmL@4&PjXSz+Y4@XbNr-iRsV-e68Ps3nxFIZDPowUjR((FfG^r7?+~j@K2B zzF3;flQ$G?#0bz?8z=cRtj)v2tB&jeCn1BMI!we`AL111%nDC;;fXp>M7a?sXn|K< z@LTZTgORtsyL_7Z@dsy~riG>OL{s_B`?Q@wMKP$C_khN%OZ2d_dEsf1s2y=P`K)8S zXfvC{Unjx4E2Ob2Vg8aah<4hPQyt(#zKaAR zT5wqI!f2CIZ{Z3&cSyL?nXkPhjj@zO6*ptT1NDDttPScE8s2HrA9|M{n5>)}-1U?-=r+n-+59BHW#m(=#iulTHP$ zMw`<})aK-wHnZ`%(rCIc#;JkPHHy$ENCt_#N39#3{ph{IrFA{I5)ar+kaYoa-K^y}Rp$(66QPySMl5URV!HFaYvA?7FSm3!m&9i7Q7GPD zWyFoS47qY-^fGmrlAsQ%3-P+5a;nB< zV_J}2X+t@mx{>FWd_@O`+eROM<_q?cjIpKGfu6}3m#`WU1ux!7mGnJgnlg|HDQ1&V zgtf`D>u^VV9Pe_*Chah|u>QToteS}S9Wmu^1&kKF)-5M*0U7EN==8kn>^{L=V_en3 zfK_E{e@7l|!~Te)Id5D)oSZ56N%FcU(P*9>o#88*oIoP(M z*OevOdo*2umBX9WZ)+mK2z3f;j)yQQ16B+8_4h}KM$E8u?_+wwG)q~H5}KDx1y-_} z9skiM<;vEP%;gbaav_V-e!tLeZN}O|Ty!h1`rIV~+&%3^oAb*+{oY;L|^mlLd z5BhhHOzSpDSL<&{I&BJehu_jX+hlx5$K$2>3el82a?JVm5XJM6*&o7x)E8peJ*5At zFG8d^_-fHIo?`!V4^O-RHD@Bp;JOgU=Rn2}g)9Curun=7;qFhMn!MJqVfgge*0xsB zI-nv%>p(36Dku^lQJGYPDAZD!Vrvx;0U?Q)kfE(rRD_6#$Pgj~8EPT5f*6LR)+#b2 zAreSsNK_yRNgg8->~}w3;I9$C}FijPM`xW(BWX9gSS3DIdE5^uHhy59|Z*@tu3Wq3fj|LzIxz`jKt4(9^CxJ zrHyH0kDRj-zbbv&w%g+gIrZ5p*oZUx**f-!yW^fqmTT|(Ehv50G3a7o{qNT=m3&Oy zdzrV^7ybF3j9p&{XY>2*f7+8(Q-0s=i_-TumEWu5mdrtwHzspS-k~-Q4 z0eS2h(sq#;4s|1)FB9|uma zzr{@8a*^9JLzu@k zsk3NjQk$5o`&T$-UnJ@mJl^O~x;%K#89Um!>$KA`wDjM@*t2^c`0I&zv{Rup;3wfu zy3tbWXer4wq7MDtO!S!)^pC#i^Nr{qK6P&ja%VcZw;gz!AwxYiSiLwX_)DjUTmVi?DsL#BA^-M;)4V?32@g!8;YMLI^~ zd}occswPZNXxM}aRgQ|SIc}6BZ%Z`2U&lzRJYRXPGOaQ-?o3>|aY64V2G`n6T0bRQ z{0?dt%>InSS%)--R0kp+6h1H9x_4pke8Wm@_L_Fp>QUc^?wop#A4OB70ltGL+uM=2 z=zPRH`vnafG5eGf@g`0Th37rXmrCT%ZP@YcjnCc5XcRWq_EdGOCbVwvJ?l0m!4yZ^< zu|F^9mxlVZ2*(+XRNofw7GFDG!Fl?^icf~-4lVYW=V5IxI!-O;ENqM0lndD#{?;mBhwAyu3CUlB+b^k0z__CY=sYJH4u4Es%^ zZU4_&&&?gbh2>X$U6p{`jXY|8utM{ro#nn?j&&`vaGP_nk>~|VgDk?iYrU$Xl=q@; zM2$q96}NC0*1^UN)sD4L%yMn8k}RIL$ty@5QdX??mJuOyaqG2vluyJfIldI4H;4$C zhx=TMROX0pazsUJU-+3tY4pYRi*Rd0+(SOqCRTl0^@TD^e4X=8KRouu5QtSnkdQ4}dCEfhP-^`h&Pn4%a;UQu@u!>7hK$!q+4#8Hv0?gp}Ix3W6w zkyy$}dRU z`(qZYld(hDBo5+~QrKSPH2PA*@-F*aw{)Uk5xVG9QLqp7Y=l*V113pXAa3C3iqyWK zGmyo&&$P#s8Da{jvB=R2e*W?~x=ri?(gOcV+lr7Q;m)+m-8Qzoteq}inbPL|gv9V1 zQ&O#KZWw$GF;m)7+@w16@FwSDk*q(#D9+*}7pZ+R6$ClT(I?d#o(?p&G}d}(*^o79 zA<3FKfLVd&+f5AST!eMQ8cb}}F{M^Kn`1?B@gBEqaK-p3hs7QoPfj0aKIaKb-ISP~ zmY$kUv^igJ_HaUYCKeas?38Pd+2-u)9631=q8B+80a2x?;CMBgPh0<6w?nCs2`M|t0rS0D)f1BWu z>m1{3pKHTBbJ*vm_f22NGZBj$KEot9Cpp8E_r*gTx1uICsVVW&Ir_W`Q0&~;#jy)w zm&JY(yA%iQTGtik?@?Y~S$FaB7eU)3rl*raA^MoOXK!gLLz+ukOjkXbCdo^7p1;sMv4$vv z_}bE1$sVK9}D=_{Uvq>#jToGsVv*DfTJb#OL{LJVX{Gy>HLkowjhvpAi`47jh zVv~CWJG58OpAPnMY>T{$U_Rt?5Nq6;uFrFOYYypCYA9;#dgW|zEy+XoKy;plI^ANQh3kua!ie|v0vQqX~<_7e`S{##p$Lb z`H;^-tZ)umY?YU?BPvH6!}*mX=X}IDH?b#*;(e}rUH1{Bf0;_3Uoo#@NyS2(ONd*D zZHP;VW7lV0u3f9UHg(y9KL@YYh9eV@{>X47PMIwp6{m|?Vh{&PnOQ{e9#6M9Z*$Hj z-8kRl6OW}HiwrIpcP(7$rTkX;g)`0K%K5wfkOL22_i3?K@0{gBb-JC|c#6XFjVJQw zH8^2{ooVDNSa>3IL-ha2hrVUbG*%o^e$JHY5RdRX6~3}mJ_xs5dq7zTKv826(U*K? z(OJk6GZ>wU;)qiL#HlHgc?*b}Q#TXwa}DdeKJD75-CMP<3RUG_6|3xvs*BP^r9?GG zl}4!nuLCto7DbK{L@}bq#oviVz_KpqI8xe+Zc-3MaBoIBet!7EaO-d@lW428*Tx`& zkx59HvPR4o)5S)yjML6>;@spQIQ@qMH?k6aWJ&Y@8|VW2PjF!EZsj8}f+M0d;gtQl zOr3b=zx^m0NA_;TiS;;Dant|dhv!92i?Fm`)&R-v35L-jG-`qKD<5TNR3h91oe$)j z%1r-+tO(fzbTqB@Zf?=zO zvh+3T`7B06)oy1re1+zOoWA{GKkigDxGMhw3#$H9TA)<%#mZgtn6V=x;*Y?!S-AGmy6J`?Lcc#>mFfqBEv&=(9H z%1=Ja%_?vi+y@}BlwwBWWeuwVrKeKd%X!L?aI_p)5!ol%3!0jqil1j10%-{#Osou> zwVuv(npOL${kUHN27bFUQ{4oNICHf>-_{Q}B)sg5Ca)XJ-W>OEkh6qSceK9+s}H1R z0{Yf$&bYTpxiU#`@OtoP;4R=)VCU!TgMb}tSJgV#uB&y|npH;UyrHb0*^8w)&J0z3 znC#QRUd}h1?4o;=Q~Jbhaugt0CxlrzAk0d{<3%pM@n`u<8|*R3%5*V_Q&*JaD?7`# zYH-95lrNwWvJ|&YdqR0ODnp#fDJ_EePC=h?Vrx%yvAW37*U!h#8-A9))ZW_O(k$i{ zS1hPlhFdwgUeltOQ5E7kP8SEvspVie>LL@m&juD_8U5|rvF7{fi|e0BuK_*~+y;1qJ$l++@D4 z=9tz;4rf2-5yzE7ErR2sVt(y8He)@=YY+Qx3GO=Y?3`$WeP>hleg^56x`jZ zO;!@cWX?wX5?hVlB&c|lfuaG*#8w(A8lqSiSyMH|G@>)fsMTW4>jtzif*pQrSzyFaR3`Yh(CC{JG*y-ly})U08oX1fRAXF5j9 z-I8|tQ$*5Z?(n+`tVge=wjKh{=82?@RE6qblSaGYFKjPl3%q6~%Y{~&<<0>4vUrCy znl;eA)gTyt^UmC`>$d)#D+b4ty!D7eK!?0u6zmJ=s>yW9%`i*itj0b77yf9BKhIxa zfGdS!drqjy#^`=J0;p9_`;zYWnUv0HqVlfEsGy9DP2(n5z}a7r-e}T`iBL--nMj{& zzZ5ru^^HW^*#u8;>NwC}{e0qe-x#kLpBR!%yiRt%@1;G(0=hjta(i!8Le-_Psi3WKzwi2QGO2^uglg zz19y`^!Cn{S4xwI)fN!T7_w6&>v3y?`mYA^A)|x3xdB1eUo69Mpc^Z-4&$x-$${5&-M%rW&*o1zl0**dvlReJrQ~c<@0oI(Uxa1Ce zbz8gQyt@;-`KBV@-G$wvQ2bE8-my7VaZwM8$ju%YKzm2z1P^qe{Uh>t0|bS(enot1 zo?KYJI-c1rAFW?0Yps(H*W1dNI=K zMamyx9mwqQfmwsUa|z?ouI+y;X+Iq2F~KCw)BKh2i;m1}|NITHj2=ec%>M7udstVt z9PHX#L1Y~SBO zrxL?YDjb>sxnLpm)Et9cBnl5|PCznX!XOP2lF1GLp3}qZ-G(H_I!Cshyt)2!Dl10b zRqrsK#}my)ALL(h5!s_-_?K%$*62unR+7jA9na5Ji)LsJK%9XAX(GTKjXc;g*^+)e zZ7T?VTlFa|%Hi_$0g0w0Y$b0Q{cGft?_5ije0sH7HHgDu;AB3pbRq~N^V>_+%0XO@ zCZ)9g$S&E=5JF!^5QduY{f$whWy83)jKI;sl~cjwP$l4SsqvP@a^4!Oe%zM4UTHI{ zp>ezHMqBc_*9T|KW}bYQY^UUZ)KIfsR?+r#2KX<}+7L$X(*=?3ildkUfA-Bm^kxrsiRe-491nK*Q8C`B zH@-y2L^5)QUD|OQY8`Kl-Nq*?#?<#3p)n$`=5m-zsR%Q_bol02f)x^bH$9$<>BGjv zUCax}*Cu}tlF8mvs{adwWG(e;!%N+U!KBg>DKdsPh$IEPl?>}P#P8yDr`PdIq_MSp zA#)JZ-KE+b9^d{dxkcuwJ_sjn8OHor=_{T_zHKU0yi2kbyKfVH2!^$xe_+i=7F?Z5 zI(zN(^Y~?(zvsWE$}35imw=&dn(tW_Nc>gB3=&AJ-zu8(wbw4Ds%!#`M#9Jac-v{<26|(l26C@v_PQM!M({bKfDretm zGUm}GGK(#|gWeI55iHz?Mnz;I&I@Yj!+sCL>Z)nSb7M+r$15|1T@}pg_AocW<*5*} znhJJD0Y69oOgs~Mk-<78w9(x<-zR(&T|g2(qG56)Yc{i4n-CRPL?ubuADY+@26cHb z8$s#W;?m@=h^6h1D~M;?%dMl+d)3kDBq1*v4-i^x92wLyDd*HM(LA{5HK_Y6V24%W7GLeXtZ<8qBeh3(T%)045K`xwfVU8Ad~RqB9}of1 zeo%Xl_DG+i_4$~l4`OPZ<}}OQ2x;f!aA;mY1Djv&LmxYw!)R$}@2O=w)v%z&ljC5y z0V&m!On?-?`ZJ^BdK-ZjRjc3F)!#D&gs8W$LD(4#VmVb_A4`9dciK+$IqfjrwdO&R z=(vWa$J%5NSd4zSqS)OP))b_ucZZgyDXL`gCHbzAP5TkIuxM6RN`E05!M|7|jCJka z;;7ZMPAnnw>X;(%OnEOCfkBBZ@7v%vOC0FactLVt1MQmKki222#vnA#?a!%&XFmgQ!|BIxd`nAhFtQMti2 zo2dZ`iL;3S5Q4s@+mD2%4o7kf>uSl~>YHNxqF#2U z?1R}Z150UNPGC)Met~pAtLf}n<-)8$l3_U&+W3G{=jQ zIySkjrR>i{j-qw8#lfTaceYXrai(`e2*9#sP+6%#1$@K(&c)3RT>y_mDl9 z(r=fFVi<&oTwz-Uv#@;`csfy7^sxbbeV7+g2lrFQ4C3v3sn>MXNXF%1-a|u3?PMbJ zT6>r_#FMQSYiv9O6j8DgODvFa6doA5@9Pp9Pa!hGoGn}KwJSWxvKMt)`hOkN6!g8Q zdVAtIm(Y;pnxNtQy8cR9XsyMt0(zxRWTPq6AH%QebyWAY0{w%>uasWXiPQ7^N@>a_ z(Li~$L+=Q)Jq*~KNaJVBYoTl>JSZ_we>B%GNw22CZSqsD=`;}bBw+QzuIlsvtf+N^ zcxbPzRA-pP7}kvYvKRp3ME_NWeOEB64e`zkyfcR|>08z9D-wg>PGAho zik{PpDFjx=HCH6aB|bnQEEtJ%t!+svK_g-mLM8UT(*cFh*_09H$jl4Pa}iM+Wia-6 z5eS|=tG|f$6@5eYgKLR{VUXa~tVD(W0DdFkGL#MPcLV@-9kGcag38J0?FE;|n=FX| zV<-hNv2lpqZd$Vsu4d)A4(I(;%L+BXO+&NtJyQ;zqx-F z*hb%u4 z(5XXqi|8ZTH17E{J4AP? zX|6!j^+1w#AcpX`X*NVJf~env-vYe|ViE@$74tPs`Y-TcD4cIwp9UMw z1D-f~tId^}1LxhhSTuPmesOmvK7fkgaw_^;qdl>iqPPN#hWB+P$y}>Zn4poFhG*M< z79CiSU)o=e4k;*z?9V}eSwIr?)6fwGWXt|j0A}T9_Y>p~>(?=>b*L*QZ6-HHWVUO8 zA?O)s9RGrg(0>x#(aHRbBw;u@DK|!~FsnX)BcgJEOrZRSCqG1a^#89ViG3|H^V#t{n@V^jNP&=TssgH?0mSHSX_;(A{$4&rKsiC_t zt3&f9=5A)d|7{||0At6T>{-vOc8mM}jU#3rx|!G#j;I0Ha(hw-{o8~1ALf8}0_LC0 zNaM%nLHHI{)EoZ!=%?H;opMBW^Hza<<5=5ReL3xTIy5~~H8$j$fTf-7ljEM=#*()f zb6pa`=&)tkPv$ocsQ*aN9eC>QYOHnIPi&E&?fVt`bSy^v$8&kB5dD{Sz~Ry?SblB{ z8Di|MYcnRVyUa(CAV%~-hYUYqAPwo@lyIaHryWxdfa%!A;HZW~Oyg1QSmcBZyOu0$ zZ-fpn)Ef2S-CY9GpzJ$k(qgUP^7uGewPqZmqE{c}*9cDo4u|ftYIQ{^kx(Dc1g!eA zL5QJrS~CHUtOAvUI>=e6cHs6|L2<&M7ni zj3YB}0x$#SA1qb>X$@W7&=@!5aU4S=nG*)z8dMw1;M6$Th`Bi(R>o-8$4dVf?2JsOltoY{*10@5Siv*Z=eZnqlmzNO+pFe$u{{#5sUv}~b7JX9B zb2hwS2mngsHo`6%q0s^m4-mGgh|V2AIn!PTr2Ir+0@x=Z)P%=>A003|-TwIWa=)->B!Ce(eB;aBHYZy0Z z{~eO@O-)aKl+(E}wNQZZ!)r|NHpR6%qGL}NFsW4GHxrDR#DBW+8N!h)2W~&=1C4OJ zE90USbCarXGYi=FJx6cf8Pf`ulG!q$TCTf0yKy95Sfg;en|6QXRHN!0IJEsz`~yvj zl}_fApjSV54^bGl#j?p8aU;xKaK*3xBJB$YkDhO_px3zqgtxHah*0Mm@3)Y=IdC^) z*a#}xp`|Nq5%Un|Z-fW@reP9c89=rD?;h~CFtV?nIh49(FHA{JW&zaA>yL2_Gc;#5#A}RjjBvl z3(ZyvLaFON%Tl5O{+ihe|jG zs25Xcn0GxQ3gXCNrx5)xj!?@6RJ7;D+}VA zHzhK|>;(DzI(c6!jgxQ1oJK}S(R`-X6Htwi_|4F4GTX7=QsEaJ$KvUB;WsfZLjw>f zh^*9vvFcrjBtYY~X7+NX6Ty|1{zTgL+!h5|D8Id{GFK>H=92A;Ks!$(jWxv@_ZS7* zne3}T>v!j}Z$coj2lJ=w-YRzw_5&xy&+cyQCWOffc6>0az2~Zo-LsrI`(e*=$Cef# z+9!NJI_`p*u!Z9f^+3YRX#52;;j1Z{ZMmRg&9=B4*>1&;>G9d!qB)u-=XkNA)#_pW z3Z|9(fpbz+?C=GXLB(~qhq0aHQ|hg|Bbz--{(Jprjx0Yp6dfILIa{<4eJCO;ShNWp z8<9QElqycwZ-{TsQ(Ug!6yMUVNUwL2HPRn_lI>q;YbFc&F52y0`vVz9l@*Gu+ z8ckrX**mBF(Q;AQ) zR#`IdC5~VZI^_5bJf!V5E7Z{iozxb0duIDXcYESaM0F>zpQ8E7?A*|Nk=v;18_xzj zG1Z%acUWm*xh>Zw2`g`w(CqzA6^9WQ+cjnmv$w;U%20Jv!o1SN%q&UHj`v64OEm=oPt&0-O;v`b#{F|5Yr<~cp=hV4Yoc?>C6fe_AuO$6 z!rJxD4RBU8mGn?wRXsibMajv~1eb(A;d;V0G4~-(g>49K&O&6FU5&-Gqwq+IGdZ?l zUmU5szfSHEo!%{yO}IGp2Zjrhi#733zTSmNXn&QcyH6|5>zuHS$8J7prtPZCiD%i% zduic#2PoMDJ&qcl`&t+)NX|8_*62Rj5S@{eD9m5YB0xry{p+n5EiG$ zwevQpnF}BG)Kt^rb9F*nAf&o}ALYu#wfDF%af;07;qI;;m-rnBL8p)&J)HMXgf=R6 zFjwaJ168EgXz|k7aw*VC0z%-d2GYzV%!7#w&C`{bIyDnMc8h2X_j|S|Omi;Z4W2_~ z@r2Sue!e4|9RI+)inCi5CISk)OLH1$NUb=rqYy}P#f&JU$rx5IVT9_S=g_7IT;sV&JM1%RnLfAd8KF^-JLlUn%6B_LyOMsOVVq?j`!GBZRW8FK%-%~YITCb z=)Qqz0CrC)jgV_1zybDB0_c|lr=gh#Jc8*CqLx#L>M)NX(BsBO(CY3}KF zbp`(>GOQbNJkSu?1^=zf_}?BEz>Cvv{4WF#Xf93RqS^xck8UbqGpYH{Ble7&QS7iN&R(-2F(q9VwdF|5n&UfK(Ls8 zaG4-6tmYXhn(=OoZgm^}!_YZH*;~z_Fvp?n1F^tw0BINY#mxCX@_{LG;n{{yqR8)d z*?vE|^D6Fd!LP4BxqhF0_dUc&*v9OpL#9)q;Y@4`^~DJ@DLi! zf*6xEs%7qY5|%lJit`9d(BI8^*Z_%92iykyT=j&*9t4LAvxM6L$9L|8dP@SlqO>pv zvR(f=h&c8%f;*fd9O!@i(fhfp(DYC?LBHuxQD{8K7nhk*}Nr@c0D&Q)mvk z83vsHK;EZAb&J~|@AufLS-3<&kK=Qn9dPPqlbbT|1np&X9luCmu2jUMzpx=S0t3{8 z|2nwUT+M77mjXl9|Lf};*QVF62UDA3+9B^ljDmVd`~xdR$)tQTd9d9SmGy2z2Oo>7 ziSGT3M%-v!6&dhCFfZ=1RNYOTlb04$F&&+palCT9J{)bXsw z65PkjYF-)SB(Lm;4jzaF&3LuDiAVkapH!*nePC{lZ{p@ZOz%zAegphERmAW6{vGdu zb^Y%q`?yBl9Su4edq4k=#qcXz6n~WCKEAbN919`|PSBT!WkTnc!7$DW*Sne(C6jXDYxq`r^_7kkHrK)pj&( z+`w%6Dn5VG`K4PtR!?%H`wi#T`R4;2iEzL4nNK**2AQ&mNd1d#nY*Q$_&sPmC!O%Z z+R_j-1A4Qy1!u?iyC_06L;3)`3nN=VHkFpCQ>@4L8n*!7S<563uoae?7X3aWn2^a} zdMJ`;!NVk7zf57FY19Y(D_^!g*|>5%XT15K;Oys0F3dv@R#^r#JsVWZ$XfbQBk<3Slqb6n@b)sL!eT+=XIos!PCd?t5y)f}! z*xF#$KH!uMa4Z@>z}x6nwi!RDg8o3}89(S8^}TAC7e#ot3v@?h*sT6*OqNLPaZ@)5 zL?Ag)Q)(81=A(?}CFo-|7gK~^qfbm7xjxW`+GP2PHfYp(U!xPSwM}k)z`TFERjMee z-{ROb-hU0fKcXPGKMTDtg2d~uMu!_+fU5!W`}J$%S)uaIdi!{`o19f|Cu1ec`St&N z3rka!Q)?neIxpgtD`!;<26zc#fj~y1YY^i;V?T0;Wc; z(wxqRTE5o5@~QxuxHRzGDeylWvE*Tc0S(~wceN(Wz&9PZkeTcOk;0^?Ot_FX0(Y;d zw~VjVbtjH}|G(wpWj@qEBb##&m-9D8wmeeYbM>XKg6BH6xGDx*gXy1&SiwSf%}-bq zeGNR1+JZ*Vu{in)5&ONwJ7J$$vb+;HVe2f}E^jzFdtqTX@tR#kU9E?G`CX1}Y80;VwK{^VDcP2F}gNGY}#>L;HLe`c>w&BVODv66EIfmuPPFtaD-4 zh!$zmdlG@0n6jgj9)ZMeY*L)rHC2F(AHE{X1NQZboBjqo^#28C6dMzc2!ciPbaXJh zOPw`}yM}{D3xeMi>|jR%t@Doro0taR@>zTn3b+&Fl28w71I`$K>9eZlZ~5C3-YCck1#Zd? zwNx-J!iUCqA%xc$@vi_I0O-FmZU|($B)#dZy?F_6s^)fEHFcR9&^|mzMG|p3s69cq z!YvN^?c2PN0HapuAf4oc65S2ZuhoVN(a>+ZEFKZ4HNrK~@NYpijvI$kck4cFr$4Bg z4C*kGYf_n@TcgA3)+hj9QT4y@^hRSKo^NmDuf)GwNT0 z%ZwI$+x1FNn5p^Vc_Vb9C5wHrVQ_t~b&;zWsH90Z6bRpn4s9zWR;^@s{!@B5~f;Js&g!v@$r0I$? zf^k^V*quGt+b8|A@$~48LPKPfAZO_G=+IT1Ta;iZjy z&y|*-<8r%8Xt5@8B=>p=`bci6i5x6(Jq!>{crN3bCiJzW<{COQmx^Pzxl5B%gqx$| zGN+TIWx1hPL0i~+%zaa&VccIvK#XRm!S9NBu=~2TGEj^xjgx#($-hD*V0zU3k!#Y` zJOx6d(Qn6ZU|br{hO?-<^J}R?Qs5&(!1IP<+HtY9RDX5#AboQ$uSC~{e0^fKS|LEf zyA%GgAkd`D9cjF(c%S4VuHPn_4UTU^pJZ9pe@=q_OoEE_+YEw3CmxKUPeg%1U%7$) z0&@uxsEVwG8A^>oTCQ^DNwMkcsNuFL6K|6?-cT7kg3`YrTie7da=Zi zavB3ON6al7Qha$xNG3>TsJ@@ffWScz zXs0P{&sDSwPQrPI%R05iOGCnmHy8GW6eN&g%LvLv8y64oirpEX9 zeFUuBVqzxd`A%g_PJbf$thx|_#Z7B;?EW4Q-Swpb(Ki{fH2hfSS5gz39`^yvITmK( z;A>l);4c>X_EOJCg%eNVl{Qjjb0!}JHva8BOv@cJzJ7vtEv8sJt?*0Jf4&%|4+Fo2 zn*y5sd_|O5Ky4&R1O9W@1DS>v>J>+Mx{LS8WP znc~TeK6Sg}Y13UcIG+rhKHi0=vv~_8AE8dwZVxZ4+!I`8$DN4EuTMs^;1+++eWmbJ zl(FP*O~w0#-{{N|%;^Oc={%8yGs6}f!-`s{mpVmkoco5vrxT~0r8-Xt`$b_uCu}#Y zXnav;FPs)Cxn4~VgqKsf!4f;s5{5Bv19(vOaEtWD6=E z9AGVoDeFtNFb7N1gBr{GxFa~9nJ6szMyIJrPa}{ue0w5is?KD=7f~I)@`0Tje$p+` z`$xG^H=>nE2j3_h#rjthJ>ii1`X$_eRGkcz1F zHBgLu$IA#@sN_X-jS9+!d0!s54+M>!LY^LuF8c^)&I6 zzD&XvoPHszKoa)eK6du-vQ3?4IW=}$`nlw!2~yvNOOJJ&nQtqVau7f#o-g-9$-Af@ zz*7Rx6b%P)RP$aTD51>s2GTQmJ_OGQkq!U*n^`b46 zFn1?aQwZ72mHDc(S}$A?WG~scDGaU0Up28Sh`Uy@z{EXXupTM7TrFLPUyf=GX)HU) z-5^;U9>14e7K!~lJZZml@;xf41MqTHdS%_%Ph5`}^Lm_k$l(NQH|6;Ct=8^wWx(<_ zz4@dpA$}Vr=9+GTC z<<#zeV^mJ_?7cP|m{eZJ4L507wSJRP(QGrQUgHN&V6C0%5@wgjwSqucIfc7-YWGD1 zI+hc;zLJ#y4D7%aLkghWyR%N4-g=`0Z?GNY-k6mFKF-+#JS%rQRda}G?U$xDlA+jq?vh$Og}*1h%!O+unXNjF@#Mu$(<|FlOU$b06LlcrXCQ>=XhSVQi6w<| z_NIty&sVm*ASV2&b?CDmtZfYemN@TY)n8qO1$)^*iCQ1tA!N7@i6Y%7u@2APt1e6C zrNxQ)sDl+II4dAZZBXolX-ofgaHlYc-&%@4+q1WieP0$odExgOMC%Sb;y}=}C*D8O z$DR#!#|sn+;A}n%jOiP@ogU~50CY>c_RmXo4HBjy)ld$Kw@^XPoyW(&hxxgjVjoOAj#j-<26e>O<1&iwwrEQx2TZN*gi4^m@ zses7tfgmBb4^9Yci#;Y&4K2}=D4Ae_=qsr^ssJqO1H(v3VWM)Ab!AF`kwlNm6`jC; zz?hp#25#K}`Hkl6X~_k^3-+NC&4>)T)Y8uJ2LvHQ{-?XcIH^(eA^MwwOSYo5ck3G2 zB3Z9`4lqvaHqk6FyiM~1%MwYys(6p&IFV%0|D=elMd8&UKVns#3Myh9ZZ( z*=2s*)n+lNY}=DU7_rPZ zUHYQJWT~n8=4gh@_wA($7QfzzI*~YuHBZW4Z-Tr=b$>EAQPkb-C53$}?!@8O1J{%_ z`L|p>UUIS;;_k*x5lu5FQbZ}*XN;GI^X&IA#Wf4Z^VI+VmRUe5UojnCXM6qKz<8yU z5t^WU?Z{fEEYS5WueYRL*vHRjv|jr9q9?~KK7Cc0dE82wk-u8?dx&G1C3n_@Ro-wl zVvpn4xe*2k0P{QKeprz2GTuDN2dE#x+pP=Jk5!N8QYNl{A-3qoZu9F;yny6}oP%X9 zj!P!+xuMVu*N&vk9eLU5)#eDK5`gbU6M9ePPJ#LK=zTTi?WGWNUf)7Jc5*0(D<}GX zUF)y(EnN79p&%@JQ;KwZkf3wG4ItcSwHDs$LNR2)8xo&>ItaOB!o*sOfw513aJ9Lr z=>M_nc^)+xchn`gL=ScDjZRakjz*xMgqyA!qvwZpn80zhm)@L zV<$F&d{d2C6bR4Ip5q1=(?3-$ET`_kc}wg9;WyuZ9(+wM{KMy!=u2O&_?ptMNxJ#o zTbrL17<{4j2kye+%H^o{%I$W9Zplr(<_X{+Sj zK-&x8@3|iq2h`gDpLxZQ<*IkeEq36xN@fIt_#XqGj{-p#wBK=OKF>PghGmpl#HVbS zDEaufspy{p6IEU=YHsD_q{o^)KzqNLE4`faa^WYvz({DU8M?JR^!j1yj7#9(k4ruX z^t}N7fjh4_eL3pg@|8QRw@E%oB+Z=u7a0HR%yO3<4cjEM1LG6leIC4kImxvu=0Cpr z414UCIeRM=2Xw0jz!vwpw#ASYst?OyJ8;`2^8?8jv_HO@l=%MJa{03o^(o87S2PkH zjDY@4Fej@IdjH>5*g^7vEZFX1NUXt|`Mk zP?P~Ca?!=Cl_=xgnU-j2xVe&D@ zs{IeF?l)8=t%om8`j`zOd@Qt>^YH7XoVB&P*i!$7Yc;BLe#gwEF7*-kfdBee$YPuf z+uWifJu3Iz)%}659bE3el%I4flJgUId+FdhQiTFZH&WQA)nvnJ&azyXoAg~$d24)M z!iJ@Og3csmIJ44K>47VowY}kM!Yowz=8wktN8^9CuWmTrR@vpJ(U08TU;7pOBeLZ! z%MZyG>&jJC^y42b`k)48LA8v0ch>vl+2gD~ch8jUAyp(JseGR0U4|nOR_Yk@zQM~b z%DbYtqxy6w7ZU=9@=j|{;mgyMb_Smm>0zc7B*|R>yTo4IM^#zHmM~SJI9Dv|HUY!D z>RnZ~sQqb3pkK@q`|AT$_4uNN)fd0)%ms&)elD0_AXrAaJ_}hG*Df+F`?lRhIlrR3 zy6RRZr#1v8m5REyT1hOm*ET=A-{r-4SfZ`QQTbx^6;g-@_Pm-H-7XyO^Q?(aM zI-Rwb>C}5D>=@)GE|G1p~J&_wO-khjp3Dc$ZM4kI{*Vx0uHBIDPaab7s(n!sEc$_ z?@!&xy5TlbtzVMVX5d7odUZls-j$tx(a{xU{y&`h-H@A7d&XWF8e3jbRgI^{R#n_; zAMM&kXbb4tUl$cTRMK0WGRlqU3MD**Xm5^oz?H#6rHp8TAsqgZ>au!8#c_^z;qWhp zssheUOn~Fyp@vEqWeJ~Chk?nYGjL@@<<>F1!d)k~-qF>$z69pbxE|pq=Q~PzGA>5BKhl&O2MM)Rw#9euBy_K7Q%CdFd3wM~y?P ze;>jrBZsat#MCYrq1^~x{?+GyiMpR@pSi_en~%CU+<~iwTZp&$FXr2hW`Fh-c&va< z1&LE~{SYxWh8@t(`dpYIW`+IF&sRotv_0ieb^c`@tm=m^xy>Qo*N<$fs1%5gSr@KE zT}tmr07nFiclDO#p;F^IVr#?IgL^$n8dX0=bQV8J{+$6g@3>t2Po{;_0j!if2@f1- zD}i|Y1Z-NsON`m(C|TX`bFlI!fQ?$B@w(>j$SP{xcZ;~&L%vFl+FMbqJo{v1sG7QF zmg<+hOf1+7*GWnBI?92@Qy*sUHl@+r`M=+x`FAK z{taF~sqDBD>Dha)DmTI@3g~dZ^L2U=RT87El_#&&vCF6P4Vw#}6}8R2_*C_oMIGN@ zJY~{9F9f?Yc7pepN>GO2gWC%d#{XOj>x(w0RRA2;0HsgX3Q2{uZfCoZd zozuAj{6&iN1M6}M68Hhj`UtKR;~6grZveh(ECcdodN&&M&F={x-+%b$Qs2HK?rGEy zoeLqQJDtndw2M^xaG`>|EUOXs&!eo(8?Y-dG&;r*(H#{UYq@UzDEZT6mQQT&{CX!} zTOi~RtLtxd%22rhyd~hEV9Dp<6*0>A-k&$D5TPMAoNwLd++GUHj0*H9FI56Nq{g%0 z*YOG9b1vP?Tcq9oV4e-x1PNW+866bNZup0){6@x4@YCA+w=*_(7IgWUR_xZ9lI7Mv zdtOoy{~{}hS6sO7w3ceBr`AK{fcqL<&QJO5Z{5Qq#WSDi?u}Y($`*FIYcondAj5{o zxBn9MjP{K7+p63zGNTi55kZm(1j_xgJ=(lzVsXL1va&C^SDpXm!_PzZU5^Hy!KUiV zot@y2;3-(^+F=zl->?fu+cvhI8_`%o) zN|LI8&zq^;0~$OyQ13>zW7Vw`^=2rBAE1-^>)jIh)gZ2xb_o>|dfn^E=4PE1#r=_!^DRi8Z01yyAp?{w(eR~MZ$ROnHi zJ=zIUSz2G6fx0lUdpoDO9h=ym@nCbP%Rb0 z8CT|9sKZ8lV#hnVUWl37|JJ|V10v%Pd-i;(_=ADk*|$WqP#?A&@dGZaD1$3Lkt|Y|Qf+TN3}{w? zjuITWYj+psTOMka-Ftvq@s&3X^5X_x%5sr!hSc+d)N}n!dO2EkBYoC*dQW^#qQ{2^ zD{Z%#|L&}MvSkL8b1ozZSm&|V!%}|lyFKTf-`{fhuHm*2)NaRn=EN$?*_4`?=2U~QU!Q2do?aN%*D_`gzy&91 zQ=PC4z=OouOLb5FAMV~etf{PP8yAqGG_fHyDk>_Yh=6oLlcE$6M-&BAP@2+_o={XQ zR7EKQq4%N!A~h5R3zE>K1_c8lB49#ENcrs(bjGRA^S;;j`~LW@>&$rA=VYIK)?Vda z_gaMH!xP{Tm7B2I)t+@e{AHrc?O2z9SQo!omm{$*ho7W-y55zW%#8IidtJS2LR`>O zfLp~feD^~ysYuEY$G0lB317L14?=IwWFOg%yF4L(k0$ns$y{k?mX#`22&DxMzcEUPF$l;9lYua$xrPB%U0ECU<`gcXFS5z(DbRZZK7Yon(0QnMfU+%@fW zQUxBuI5nr-C%U88U)2`4*58!-JaF>XIYmBErM*5iHcC?{YJzKz3AM_#??BD3RfOv! z8EQTWU;8v_ESCrfjdbpXSjj%AfKxF94~-1zA0|QMtk36YUbqt!!8LtIqEyN|JG!fr zTFc0A@h&OtUZ~M#_MpA9T)WUd<*uD2H6~R=fsq1^7N2KzrP``zBBoAAE;FS$Myk z)Q@BQXnl4<<*^r%AwwWm(@(iLnv~>dROBsojZ(81*+1h0Hq{f{gbNaxEFs1;FKn%A zh*1QNgl4713sm?A3eY+341(q5isDDz->7#^WA9oS$+&DODeNU%(2a{+`2QPNh;>^~ z`xER^n-&~2V!^KSOw42iktv5z?kL$<8nZ58#UM&TksJjDlyR562_G3BYhe5^%#`w% zBhDYL^|&vKE7AhCto|noQ>3X%f^!MQo40J0GRNINNGOV5H{eG%91S+Ia1k{rB9Jee zl!+*0UAZfI=gk-8d*j8_yF<3USEp5a}@IgYQfH zGxaZNUQe+kIUx?Db5@?{F*Lr|29VLvJ(Yu{yDPFEf$0h+Uo;>}`718=7`6*XqkHrR z&pg(PdKvWj#qYX0lz)*f*mj`uA&8!pQO|p?589|X8nDudnM~`-$JhHM2Q31fX7l3` zVG_(g?9gxV&^uqC`=hFk!Sr5<5;PH}s^2!PEK#;eArqiF)4qMGzvhAOsLYV}dDPLT zqG~xw2(nJ+^@%&!x4Y(40>RTdL&oP}X`f=v>3%}MNIG)bw#HnEfU7xMHFbIvQ`TZjJVw z3ph7BWnG`Qv=FM_jfyVdP<6s=r5Vi^_Sb7~R_ICkl7owa2G8FUD-s0)eLH z8Bg(jO;fXHNL14vkF(w{J>RTf`xB!${N?yr?sb2AsOd+&X4eC$i>9cbE2Hah_H zY~&a#)p}TY_jIo_wE&R|C0&s~3y3e$`g{YW+M+7&AaYC=TB0*qfx2971E|-gn+4Yn)R*{@OGmp`s9LaTso-Mf6q>5X>~`3wP8WaaSPV4d zL-e@g`KY{k#n3%HddX){QKEN5vg}4QSxyg3-tM7pIay6lAODxV1B!lgqh>I3y^GL+ z!dDf3K%tEed|vFb(tqcya-a<5coRIRFuI74M@>52FKT7s;&iPf%cnA}uOCyX4VJv- zpO-AIxUpQOvwJDH>T73xjoA{BO(Q>o{6w-dE5JC0xb8bB1Zfk72>fOO`I${;QGiJq zF$z3V;SQ>gP+{IeI}v=gJ1}rh8;CtudIib4?{lgZ&7N4jj^Hv%t2qsG?42;Hvg~H; z({&4TX9_>iT-a?=;zYjuK3zod!IeHsa_{y@{j?jXdq(2Yz4poHQT>~#VYxl0-jeK* z>axZ~1cmx<>eZ=}HvyF2!&8QuSr?vCD?%H#h?wG<5&epp`CMlkHi?Q>L1Gq}%_|Y_ zZTb2y9TF%LMy-o!`AwmdwKh5LG%3bRdnKFLcK3%Xws>fV$8Jgqch0w+N-%HnuwT~n z420ZHSW3}dn2qdY;im|CuOMROiv_y-w5qu@;k%uk!pl6h#mihwn``)JKz)ku1!=^p zuZ1$Mq=x9TR6V=<8uaSjC)F#n5Aq@;(=fN);lrhY3TKzapJ-HTmhB_+!kDS0Shx>b z5<4ECk0C17=Tt42KG9yLw3Br3{yRu@vHmu%)n)C|gb!nQlO}JnhA(PfP7@y20Xf!Q zQr(NxKi+XU-rpwj$DMzj0JWb~zfB&;n>2f~eMtu&xPw&hUJL;ZZ3p0YGT(XMJS-bY zFR{c&$c+}a3);2Q4%s8N9ftGy?j^n4Hrvk;a6*u9Q6tmfq5oy|H2=%5>kiieo49Y& z$I=Mh;Ov+M7~K*zg`^rUH_Ut4DLiWJ+x1pm>FZKmE>>6}=Str%$-mlmS}Hzn$Sos^ zQF9w|X7`c4_(`^x>*5D?kiNwFUtdl-jEj~d&BRi!zYbEfZ;&{Q6G(E4C|L-+mUXQ% z^?AR*pgFe;Y4HPY_9yhPm&EvhQAjP7_s;F;8c;QuoK{aQ102X7*@tfa8f)Jv(~+Fo zhm^>=26}*&;PeiSVgqviVP;&LJX6Sw;G~h|@Q@NW97BnFO*6Dd>^cnJm;}3H8Bd9e zEF<{TXDBT^8tqdHu$%>74GoBcr;IG-bi@wKGNoFf3Zz;OiHE9TB!xKtFc^P_BOv9mfe~pe6Ri9QT(e< zML@hIv(5tV3uXx`Z|kfUNg4RA;bem(-*@yx-+S$~uV`;+=UUs*NAb9wB)56_lG4fw zXbBJ%#q}40=&)?!WWN=<|H$C!A*aBZbcqG-pM#(q-5hz6YW9srg}^ZPUQ%*3?xc0@ zJD;1SJ-^mi^-oz@=MjCv83jm!{zx{Gcx5E>+(Z9v-#N$;+dPcHm#c zWrpH-cz~fGQ7E|BOyTr$@ZB~!xEPccYA02_pOKwDo@~|aXl0VuPQrT-78HZ6aXnS> zl(AtHWo$VVf3h^(A&`|R-gtBhALoU{$4QZ1$N5iuuu3xPc(JNN$P@TfFQ(*MnpbOZ zMHwR#?F^@ztPs~o


7Aj5rb3-n%8J#R2&D3O!3;7iwSn>r(rHx9z|X?!;+2+vY4 z5T`qHYK)VR7(^lxd`o>k->Y$3M2~$@;)zYDoNi` zdH;0Zevn1~ZO8~c(j!Ywwy~sY%+fTRMbTicatQO!$?OfDZw8WmS zm(*1Q&+QUsxpsw;-0p;hU*G4J5s1`V4FzsQHEL;>Z1_?*Lc|cwmy$_-e?i?Oj|hyk zKb|2v%=}?f962!Vn7~ZAkF!mYcKhfm+uAx`9778{?=Iumv^Q97TXz))VJH-$lQLu- zkC~K+D3n7v+1-Z1A5U@u3QrdLNU1M_4APu>&mA38nYh)G8tJYUtRJf>b;f|WpRWJG z#`XvK8Lx>~FMY6xO&c^|aTsL9kMm?jZEEuNU=#PyuKpYI8?AGHkeAF;)XXO+kdZO_ z-XBA6{%U~UJX~7q4F%8d-ZAe70W`%Cod5KsMzH28o;rr!n&$gG{^${i&2$ju0K2g- z*!Bf1*fzF7Ht|;ivpJC=YseH1g1G1ShC{=qw%f90`MQL;2)yAi7n}D#Q7YdxyyxWG zIzt3PC5`3H>|8jgv{>Fe}1ioj9985n$a@Nc- z6I$5^5PZrbOX@Zcbn-E{R4dAb<66G0qtvxxGW?SV8LmTx?V!iRG7JovQrS$QE+!8F zd4mjZ{yL}|$R&1bW?wVKlBRd=#(05jv$Dgs@xWvQc;7b&6M_(vn%nJjtE1;(%`r=& zD4?cYjFrn?lJ4e!9qf|5Gek(ZK|bD`t!gAqG}6e)TZrs}-)Tc<%{pIypP^D&{T%BG zQvz*wkal{m;8m>j`Ez$$8DYYyOlz5Wh1CX90^0BKSh_=?Vb_ zz~($B2>>^!IfP z9?hFp$iav#(&9XTF$J<5Fv2!@?7-^oZOu~tAH?` zn%VH3M@u%Bce(-?jozJBr|vm<9LRfE0m1s8!zlH882w|BBj2-dU_7}B_SPiQFYYA7R1p(EX$Z#@bDr6%?yWspt zkl~#)AUM*knOHeh7Ok@{m3Szm?ZMtiHr(X05uju5SU~Y5tB7;Yd6he!{!ZZNd*3(h+q1)90H-u~9^E@z zk@LLkIV&rj$sMVTfat-WY+dzK1i?Ku`$r4{X`)7kimoK7p$^d4+|&$+Ffim@%_&|y z>iUsRJgj(jy0g&A1m26OsOiHdTOD_Cktitwg)NXUSH`jUoFn~@29KR1E)D7rIYVHe zviy2y>7aF>qwGuxeA;Z#U}ajCTC~{BrfL{5iz{%{C@EWY6jKR*;D`aeU4qE_=Md2&*ilZP{0*tB5@@+o3kQ) zYghB2qPVOl6Sp8Jk!9xtZ7V1b)+kPFSsBX30Pb|0m37?&kpsMrKCb_ zaIw3VY3pQ><92u{&+TxRl86D|W^^5UzRT)gXDJL{9>dj!+WKvce5S$DdRI(X)sGXTXSEN?hfrg|!GN<^b*l3be0 zgESkXEJo!DXKGxBt3m9HJ3M@Xj6@o&*-qbnj@$*{xVrlp7_{G=drW=wG39a1Z>W< z&q>wV7vwm((hHGk-R}a9!iZ>5=?UR7;#n}g<4Kd;Hwy>oXVjdOW(qibZbbLqQ9Uk9 zaE=oDc6aijF}y2A5xo_wV`WnW7)j%{Ddq1}RdtPV0x@8upq32Sq&8}d=B5r`J)B#x zDWRofF+17Vf^a-pU*72mT?>AST3wF5dkpT|YElseacJg9>?rlY_aZHa_w6q3G?bdL z!PF`@mIG6dd7Lhknhm(%j^3j+r<6dxR%Wn}nASrA_?U1R5H3*Bh8fTJrq0|3;ZINz z6IQJ3N=R$#PLQl-tp5|HC098h$yEl_q47zmYykog2+^r|B%iXc-SmJ{Ke%DdQ>99u zDD*sXw}UY}I2)zekO}*(z{XCdm+YPxJ<(YXUMDjh=C1xy zIapbs>2$Kxg!=f49nx|QSJtb%^wZDpR<>{;TusgL@_D+I$0xomICBfxA!_O>^!%vn z;1@OMS9wt`#v-H0fSbr|X>fd3n3dsiM-ho_Ho{A2*y24wg^M5H<9gZwF=+8oS>rOm zfHV{iur$3BsQA0-gh8F}uEdQ{%Qz6`doRA7=UjSR*saijDq5Rt;^ip$c{!|YvN!0h2iFkq{x*?Fm5#>s zH7ENCMj9o;S`u;dr8qV2 zd&`8siLm6maoav}vbMbQp7+Jjma?kDKcMfAz7qwg-Yi3WKBs!7iW5BleHM(+mTdW* z){foU_ZReG57bT67nyTK3%$-iuP-CZ|mmeC-C1QFX{yN@6afJ@~BJZo?QL2 zC#BFUKTWkUe_c87TJghcMUU4i+b7%_UO(OMX&fOQzGEQVp6%N}8sH$VIpSasYjktRU>-f0sa{aE>;)EN2 zJuKoE?r$@*=sSL?J;3Poe>z_1ffgPxm#ahlE_>E-zN9$eW#Yp9*dK@c1J}Ni8WUEv ztk$~|=6*#)7eCZx+O!t)-u&%AIr&^p-TS=Ubn`RQ&8zi&r(pVdF-Kjx z&T6G*%5v}&y3eg53F=SyR{(e2vakOW-7ffm{eL>Xlogl1O7wXi`uT@^_HP0N=sKKr1DZvFiboaADY19jHu@fXqKD$!7r7sRHnX0&^{Cw}5pb3nDV zcLMj&M^WYAIE{P!Z{Y*9uRZ5oF(v+FDHdh+zHBvL`<~B1)$gt!i9X7avxKDporV99 z?N?+VGHjitu7M(9_se<6=`Jq1i7R#EUEMw|L#-SEfil--7XPg}4iyGKSEd(G!j5nB z3nORkSw{oBSnXY+k3-y#qZ)TX;?rV=s`2-pIKUSmr?yEHjeFObVsD%FtY%)Rxh#V2 zEUV`U0@0xddydweNtilmo%^q~2A{{S{h-v~OK=^@`Y(8RkY{9CE+qeLrx@LU*(*&& zX>M8}Ed8Qy=X5nH%R@1(wSO(xU{(RsmD%JWJyUF5QFOig>!5C+^AA!4+1Eh5$0($e zm1fE~ywe4`npE}v#47wB4>2P-wLURF`bQyzeOt2EF5tY`l#xabU@)OxMVs&B%3YgY zmjG+GDU}*2UeyyPM*pE9@t<@RD(|vt0E+cju#vx$F|5KXXr8jb zb*=W&xvZ9_zEd6`!ywzeFQO=bq!Z*pzfn`z`&P$(>UI7OxuKl&6uf&CcbAm-RFr~# z%%AFKPyg6?G?f2wHfykJrsU@qVyHiXHumDdpS$dU{c@>FX8&FXdJW3mph;*5V)%YQ z*KLX$<&C6kga0i~fpY&@ykB*x`^quv&x^e^`v27Zd|UL+0D(n)j3V@6YUqDg9U^=N zt0;>8d$<@adWX_B549gym~QyC;$_@}g4cQDzQi`r>5-b1o`;`A}LwN7Ch33 zp!~2QU)IT)MVx`0MKSzJk8$!@h;lsoqtga-Db$TGL!I!fjD$rUb`1mG{H|z+lxoL+ z+%Mpi_N$g=Kdgjk+8^B)JyurdhSmFOvzU}%K@nKVIj<2$Z-k_i! z9$+X)6w&~^)r&OjgMedZL>3WKXM?>LV6{<59)E(Nd21@DG|ku z7VkW+m5eXeL=&BYtEzghySkN0RAe#IQ^~Ac2M6}VR-8Hg0>!{D{&#&pV5^ccEk-m= z{ypab&n|yE|2F^3teAGY;aYAGW?(aiiD3{FdKJjmO=H67@w(NQ6LXh z<*)hh7xfRuI|h%|IxEeTYEZ#2~VNs|7HYw4e#dvrx*Z8L`eeI^@A-C z1RE%+iufrmUP6|2oe@1Z?l=ro$}f6#n-!jF7Ga!NFX`Vi7Z^VtzlsHY09X_?Aud7< z;Y*8r(ekPt6UwYI_A2p@U-z5`9iw@S0x_$g?jMG`xe^ulwcywLnm&Qg@_ujmV=)~n zZ%|*|Ak7T01|4W7Y14%9GyPSU{nCnT{icsxme6}%&bU~#orvB+M1MT@mg*LXGw(y% zwNu?*?D-;;qOW)4R*IyZfIPf=DBvgAJhnvt+o}sta&lQ zUGs_C3r3mlhYp|W*Q{f>V`0sQ!_Lcm`}#TD;icSKe>pB7Q*8A+WXn@Y?_N_bPtXo~ zB1BZsk*qh!ngtwEildeNbxkRDb&L$%MF? z$ezppaj14J>ITxmcw-v(_iF6-_Pmu2gda){^m>rru5`@QVG@s)gU0vScZ)ZUAr9?< z$I`UEal8@S^~aMem!HNP0Rn!r>3MnSy8AMQrQ55+tXqgW-#Fh0@3M^zYVthRacGZ2 zY)aGGW21-mxW(3Kf8%;1w(F;p29n{|?bYEE0{7K^I=Mi)P_>;BK4G>5{a^4t+>pWg zF=h<;k>26}Is|`9-QsDVJbq8Q2FRe9=uK1FMdZZx`{9NHJ5_G~IQbxhcM@1!Z|Aw; zjrK0?>Qr$(&)AtC7k|48oUBN3$BEmoIPc~bdGN<6e!gpU_Sd8x(9LSlW71A|#>)Nv zyq|A|S7|GwU%h~mF@1j0Y%^NADzCF5`QQiXtI`H>;zvCwST|kq zfBgJ^S=!%Sazt+juRG zER9%@cw?TOCIw9oeo6V~jrMl@A3wqS%s+hOf1@fAlK%@E_`8?=$KCeUgO=-U|A$4# zr&0fl&7;B>8`eI#J53E_A2_p7r+I5%BZuDh4I3^;+*rGo?ar=e)#{ROr2Owsyjqfc zEarjRvSjU{O^kl-Qy?~IwRHFS!QRtPOG;dFPG1|DUQ%01ORARlnyeQtV)h~Y1C*%xTP3@kQYRPboJ*c_I1XZ>i5zZ{7%MwT-Dysa^4 zJ4w5pTOQV2cY|^Q-;&6kDCnTco`QI}j~Um#bV>6rWwhNu9@Y}{3+W_&JTb<>rZtFN znSQ(5XU}0=1Z5X~Q+h@^PpWfIHm z8}3qevkcDpe8TD_UZ<4zUIqxH+VT^en# zyXhbAFGG?_YD;WOl1?mhXkY_xL{Jq=a=X-!L@{rVxq{#$*(Jf+f_OB&3Drgm!V4cl$5M{A%U(gOBOOn& zZKZiak0)9;(T?FQ<w_lGNL(dlcSwTYH8J9(|Fq zk(7{xZl?W;M_*=$lKP<=N=a&Xv;%{Sq?9y!g|U?cKg5(G!R3&TDX1hSCrf0rhmZ-B zz;>JigN-DZ#C%9GXkR+S6eGnXF;gkhkX-s#;wcX8%qAMD9qz#3B*`WrU(sCf%u5V@ z)=QBE=lSs7`a5o_$z$x(Ua3D;Nj1OCj5?3EPV~Jz8l^?M-HjSanv}yhjE4KOk=4dy$rI&ugIa=gVsYzhO$U9v(rqa@Zsf?FqbqR z`>T-FEX9Z$L3F6)5cB*`S%zM?s^9#M7?q2YCxxGwV$y`c#+mF!aI>-v2DvQu>D zIuF;nHGZRgSMA=u5YH;-l4Y}D50aZR=C|PrQkmlpb#R*V95Y~Jiu*n1D&ra@)m^na zdNw*PtI3iB#z%7>s}`->vTQ#ly=FGEX($B4i4dJD6%CS^+delG;@dqo6f(Qk6#Z2+ z@+F7BwLhd5cC;Ts9r6@4y_{xXJT%??eI0y0MKNy~Zz;3&$Tca&ticO`9ELGT5+4>{nQmyO4Q75xZFm(Ml63d#_%KDK88_C4J3UrqD@8=6@1Y+VTVl&wR5T2qUBgft>uKO}nM-Y4 zS_6jk!e`kvozFd&vp0`6&usGLfN${QSw6wvz`g7WZoK8>o)uU+ZwXG>MS+OFRz3^n z?;qRUxB`7xCp>{omIKlMN&KUm2eC?gIjfOSm9R(S75v@uUVfV>a@iVb`fLf1GIOIc z0a?N2#yL8!TELVOt>a&2G!`Jmikhm}ZMlOcLRCJU6a2a|#6>e5%Vv5clhs1tYiVtU zaGUViwTzAK)3~<^%Lm7hYfY)Bbg)XMsPcl_CdFmRu?So6H(q17l)iaJ@wiW;_c+b5 zk14Ssg+Ajf!xPpZd6u~wm%7I;H^PSwu9UqItrPcKj2dXos8ng)%x}X_lN+l~_`JH1f{bUR6Qm3x%EOo66pGu`aJg|Xcm#qo7%sQCaO-Ki$9jlLnTUK-7IMr|II^;78v17HN3Ao)v-)JtJZa+8U%SRRc z9I#risJ(Lso5Zt@g$u8N3oTz5^HTI%H+L^2hC|Z~NEI#Ow|kDR=%+Gg8QSgE0F;(t zFs7Ytn+|ELr|N02D7{M;Rq6U@j>~mwn znmk6}O|V=W?vz%{L(w3`Ihno4u_9=#1|c!(2iuhOfSL+^dLlKA7VI567plaOH%~gm z-@w0I&{)9KJP%Y9AvE{y`2-KM;v7;f6vqkns7R3j^!;eWp^w5{K%lc6b=e2n&SW($ zt+8Df#6PFX@49)65%K^*RPN5vR80yBbhnvRdF@{e-W2}(HMw0*#px115F0Bs=-INMH4MbSR0ZvTA-8dOiU?~SggT&?nLmx1P6qW_XYC|3{ zV*1C_LecBMRAE3HX}sVjU@xv?5nu09;YQ)JY@<9WrHC(dXn!?J2B|cy>bz8xSF|;aq_paHqkg>>t&jam0GL``B zJuM69AX8kK-q8#6&!Il?+80gDwhx6(zH4SVQ)t|iPQXl#hg#56%9?!HfE1=D+4&p9 z{5aeTQM{1q4TV_HfgE?{K~%4=h%CpSWFQXqxOJg(>`GUo-|nA`L& z)Rq%W;t83v=2)dP{`O?p*Lh#XIdgC29SBS3E(_YO*0Qd#5<^>o6ugopv`{f1sTBX8R zHV$l*^H>!}9)o_Je{?;~4h*R&_=(N&iF+DR>n*^>j>41)z7bqFt{}HDdz`P+oJ3<$ zhy~NDiVL@nrawkrc?xZ;>zF+n-U*BX%^TEfq|#~zi7=_`idY*P+8|u4z7x(NO&=|4 z;theZsgF;Hk847vv2M(a18oadhupG!yb%cr(YG}tGaJXP0D_Fpn6B9yA%f= z;~NC5E8C3|A?!}oC~n%v*wG4`Z$e!P%Hwj=WyrFX=~5&iLuTIThUYd_vEew>!^m); zeIdve0x|=LarRcrnJh!*3$Wav?Gk-=ak7viW`$U+1nU4nHf&R_#7Qf@=#=h1!;vyL zYXJhy@)lrdX?;MBz^oQmB7r8RE!12^W1K-CuZKQq3XE8m({yn`2B_jP-&hX<)jw9! zn81;@SbH4U2O6eKx4{CdQXZFe1~$xOckg1BDFPctfvu#ALGI8@yy5uF%5KPvPXhZ$ zPy``HEELAM;(rv_G2=LhdbYh|fgx!2l))u8utH(R7V-7QRHO+oev&7eGOfV}(t6 zg?SI!{Ox1DW7|LaDgbd}*z$0-qCtXlIQCh8{pk5LE+y(`(OGxu666!jfXJ4$fY*^7 zJwTk)g>aF$`!tGC2sU16O&*nE2>C=_0}R!IwW%*1 zI15KP&RuKdXe0O8|Fs~JWh6IAt+@CSsAZ<(qH<7Wp5qJrg z=9ie0Xc1BIv!dhMX0w~l#UVu9yO0jRXR8BmhAIG_#|*e20Qasnx^bH>rj~%!A%*;G zD=^~FE^ia>Fr{L8frB&y?h}ALUyd?1a8d|G65w`mCgEaqb2M=2BaqaTLc3)_G+u)Q zmZ$_-i)>>CDH|sV0?9HDFj#iTnBBoi8WiX@g?5uZ>HuS|6BMYGrf+qcJ5rM*ckiF{zkRX|n(kc&}6OD(9KftCeekwhlg$^>xfk>i~6m^=uE5zYW6LeCZG28J=q zZHf*7A+1dWR@yWa%ishGF9cy+3t(RFqCvf4|>ed6W77tdY&YnV@t%t0_ zca8LlBoHPCl1F&~W~Tsrj4YTrrgyBh@%;ETFxN={XNUdFrjaRJvTO}p%Jf#3xx-+C zoe*ar?}A&KLRQlTN`~B^{9aHRTAKW50(Hb7yow#RE(IU)0CIlZVA)HMGlBD`d4sn+nR#ipAL(O9L8=CP{_( zmwb!e=6BrZfUw|{^gydwStAJv8Ea482ejvwG^Pu1e@9Vo=xp3hV3)H(-Rik8ObEP6 zvkQY0fU@#JWe09eG9g5G7UdvzROurH4SAG_vdi>epi~CMO&d5jN3(^17Vq3rXc-o) z7S65iE(1+(-3b01=d~36podVbTSH?Ti*N+%O#n_s3|x1&<5`SZlZU$q`RH|x$731p zP&iQ^lM3aALh`i~rZc~3e|^+^ESIbSbtNR`D8mIZ;trg>m>GLnHxR2Cn@xZk^sLik z$ICyi1Z;yAE;e^)4#!~&3Umv_#|uTYa5<% z2h}cLXa_1RJXaKoX^XJ$a{@AkaRU4X!5f4DThMIT#J2aM!+V=(?926y=b!-nE)c&> zZ9XG8A808;%XYby5e5m1Z<)|C|3w&fL*-<60tb4lGX0Who#^sR;~O-rAFLV8pMn=& z2La82jd`DRHNk?{x!cJW z;Eq5lAUgLTj^PJ9BaLs&ZZ0%^6C_qNF!;3mCd=*x10#AG@Q9&H+@loO-f*C*i0uHM z?So8w&zO%PvJfB%n#CAd%_Q6+sC9HBe1scgN8S)yiW4j|2U@0)T@FH)rJ`%Ww4M+a zQv=p-={T3_9Sppz4CIOGpDgaC+vEUOgc1ZZR05k1Isj%+6dmTdz&zxBaZ;a)@c?c7 zq%X`ss9pFeJksx=`Uj)*=4T;KHSDrKRKc3QrZt}yk>vO#Y~;vMKRbg~vYc*M?dGBWb1K7Q+6sRLiQs=DRnF*9q0S#+sF>&mQpXpDJ!f`I#F9GnGgs9@^2xd$F(=rcbB4Ju2s&Zl-nmI^LVx6H~F@%0n-bTHGAA zrsEQ!m(b>yQ2m6|Y$}o}CGznX5hbxLd+ki$t~dUWCiF&mchRBEdv9F!%@i@q?k+fc zvxU7ys3TiMYZob{IMcXT6~A-OJv?7rG3gn5{XRXZQ@e=YiW_;>nGF(2W-r-G$SO@DUuQ4LX#Hi$ zWQqJd?D3tOI}X0pd%R^?Z0D70*SBjg8|foj#gTTrzOd?A1=E^Z5Fvvz#nc9sFGfg`8m8+gJK$tA)sHsrNL*9fn-C+Ir zbQ8W3^-^)K*?l>WQ*wP%N$1koO9!}eaMpHO(8OQjLg!M` zCB)6fU+tP0;w$Fd%vl-M(dHvN=CX7p$!Ras8_S0^t`WvIyui@49%x%=b!&BN%WKJN z%VC|ii&~6wo3sW?yU*OCP|w9Kd7ftqoRFUA7r9Y8bf5Dr*T*}Y z8qxMo4?4k?FP*>P)Y@szY5r-BY2In>{ag#&{A>8v^0V`E@v}V)xfOORR6lHyJ&JvX zUz9(2eIdtgEuyxVmYDWqt+vqTAqUy5`3E@z*vLDl`qObCHth9$RE;Tq>`=O!R-mqM zmbRVNxYp(Lfpkx-_=(;5>-C;fH#mxtk4PwRC~P_O@{idy*G zn--j#&Q4aIiurki9nz5@jCE9TGUx59TcggkZ|d>q8*mZ$;x6yq3tAcVp7o?HzQV19 z7HVU{b9LYeq54v2qB3UIPEzml7e2L|>&xu7-|EiX|I|L`D`%M*Tqo_$rT5e(2%Y$sk zQbQge9=L7!c~oavFdZJoSQ{X=`RJ&|32rtl&xw6gQdo_>F1HFS}0q%)7m^=uwyA4S!K+(x_YmRF1fx~;w{PAIMQ+#OrQt#Oyg z6j2cGM~A&#LtR6*%%<@4Y@zsa%m@~8)$?Z7$sK5BbVl;k;5*Y5U*Buxu<(6Db%-=> zb_)L)r{ z@4fgon;z}coR#<#&s(ph_^C>axwSMmY58?z_?+*q@jEHa8J>&v_nT7@4=t1pI)?3+ zZ>BWgIUJPOXxp(b@{Rk68@BKEP2W%{PNXZ|P3#v6_bU2huSIUj}HmGqKn7B9Zg7NNSS(wcR7td;_i56K|*<41&?AzP%38wX*`X zkFL*@ai2QEG-datnoN79A|Bj2UxmvSk~2lWF|P*y>#XiEcpTgz_^On)aP&5F>%kv`CwVokitQ4Wgl;=Mx2t zxChF+=u&x;Ds-vIiE6r(uv9AnR($|70~2{XOOAUe)4ylBdm$kSO*oBK|b* zh|?`XcCfSu6Fc_DoC{6jf2zIO1<=ySGu6j?ammm^q8^|swu6i?ieurnDRK_o=>!2 zZXoxoiP3@Dy~4zl?lGlz^vc`*b-vq$y}lj%q~e}1+z~fi9emgG<2p5o!`29a2#f4@ zjNtWoTn7za5X<%r`#7N*_ph)2MduxLvya9g&#;ahdW&4d_C2j~xmr*;x1QwT zHr{cnSN6%)j4$Q;;_F}7j%{9VyCHbvvolV_VO2c^D!s6A8qr6J=)-_#{1 zku!`P3OQ%2Odj!=$Ue8cK611@rN!Rz zf-|N1kB>SAdzfF5gO|8%lzV)aqdxWsX}yptD#vX@#=E;5!W*Ak-zc^JVzATuxW}0A zjgen;s>&zIcaj~S2If%Ccw8(QmYG*Jve#%@Iyh0D)-v+xP2GnrS~$(S_A~n*bgkr zXCB;@rdRyB_kLWj?Wb_Pd^2VyU-1b}O{15QQ!pNL>J_2FY1oTLI?}hX+H{UBn`;bj z2#jMN?mX2GcbB}_fA54wgzM%E{qs58wx9P1b@$ko=HZ(1w=ao_L999!j6IK&i6aGz$k}jFfeu9Ojdw6@q zdboRpdjwDMO$&;y5#Q?R zkF{mP5WE2#WX&lKY(zS4>@4YBx~2B)oY&;Ge#-Iu{sir^5F1YV*6hJX2cEoV;jkQ1v(zKsy+AGYOYT~kF&n$?cTHsrixH3E66|c+|j>7eV8D;&!BGZqiQG;rgGiLKk zEM)LzKJn8yP3TMIr@0zt=5t1HrI$1K>JC>owcJIQ=l!!;siR@Eq3+X4$aktM`>4}_ zS~wp#T{x#cI;<337C`f*5@(Cb7^N#t)2R0iNrN6rJqz|zRZ8T+-`|||-l}(o6dv7T zKBXgZy_!Pbnj%|*xwSp8Xsw$s+9I@LLav8N?rzp_xWGqT`*v-8+xS_bt~{4Xyn43q zx7y8m-Z0^+{C5- zA{%PMRnIOOtq_m%{WW(fE}`~(yb?vK;FnX;=d`OrzjAA=3D`gu?Wz}`N=#kDqO_50 z=7Tp4k9!%StFu&;+%eqk9!&J*Vnzeru}uqkE!{%PA;i$Z{QwP#Mm<#j4q3#m!3Eu6bOFvj@PJdXNOXV%8`bRV@m$aRBL>g6vR5xD zK0e~hHvOtXwg$r_d#Q=Gbe&~Bw%Zj|cFHw*{6z43{os1u0Krpifx8270z(&WZ#cGPB3>Fgg8(#y1L!}r3Q8L9N%cmu%+t;>hqqxi5K=W|!gb5S1Ej^~56>3x=& z_*T!xkUr5SuR<}7rtT;CiZKo?6`Qu=gtGkBETZme3|Z_;k#p4g80U$3&f_bpu0_Qb ztyOi_GUrOuT~|iEBvh_+X>OOnOY!}eas^`ppTuOx%Gs@{+*fF}zwLU(?&-YtrH}&D zGVk=WuxsmMJYTBq4BW7!1n~Eo>F1jj1oSAe#%;AN%=dv#=Grv1b;A`^_4B?j{rp3` zV#qEW!-3hh29e-2!anOsYTTzFqccNB7L z(_*B*K(>^~?(om&b8qRizHGwNRxX5oG9)kZL0GL2$zYbQ{alcfoQm*5kQ0z{w<9^F_C)aVW zCAGVbbsQQAe*atjpS&mf_au;W9XD@?bKE>&hDeXj{`4HgIQ!FWCC>iz+N5ow!@u!E9iNlg&8VSH zyBRywZ8xQeaoWx7p-#IgADXN$?Xa64rroIP)Ei+!=KO6u{*D-LTXr)+gx^){W}1k3 zPuh(b!xvCY##cjeo{w1Dit~Chz8)%9vWE-#?!#b3KF@jnTWyHSOLIcnC-Xk&Z=hy8 zb7}!aL9L)8K_7wsh38Lu<2lu&j%SPi#1Im4WN z*|}teKR7%5@0+Xqr{-Fwb?D|uU%Kq$8;^Y$0k?e=2AuX$6zH%IspJ2xwLvnwIX&R) zSI&l&U>AdUqAbrdKgVM?+gx^YZHL{kihr1PlgvK$9qzP`sl(m&F%2=!ac9wRXTP#| zct^kTL+)3S*~eQh`*_=9AAk1P$3I>6@p*@R{Gj^}zxhxyy9tkQ_A8MQ?tbM6#5ntv zV@5dpm19SA^eaEyenov|cQ(m)JP*#8Hd4-Gju7$-M%pLd(wcUmIPrGb$RDB&b*#<*+x<>3IsTP^7vb$0X^ZqW zMZ|byFIXM?D_sy;h`rm3Ko`M}axv%<&_?)EP6oXL>fGT|`PM!a(y#ez!^V62tfbZ0 zJ0CFuV|8aG4IfLrO0Q0Ia)3NvrE;u1D{1an^Q&5tS0rooSo5qT5zej~E6+;WMrd{;hqjAQ^H}q&q?;+6 z6B}!v346DQISMi6nXs>jn5|>oXTlbgnrFg_@8aYZmdZ0>pMgU(lG~>=FbX?~b9af* zfYLxCgH5+@ACxV7t_ZC!Ey~7M zbi|2D;#}D5W4N^98#b92mdev>Pa)~dt4qb%J=xRIt`=s~S9Go^m8b8t5#H&BQu~xx ze9QzfH!cb3|x#9l`-#*?LiYTBdyfC#+;+&m#x zoJnQ8Qz}o0?STbk#K;*ZPl)X!Lb)6&7NPFr%<*av47(it#{QuBAiwVe3_yP}7DV5j z==g?C$2W93zM=EO|Ar2_-FCkl^uO@lJ&otz^*43syDbYb&sqdp3_1|B1XK+=2(%Pb z1F8ib3|ax%NeU4Jb-)acDIN*bGkh1wlfCM zNVl`57fzRF+vZWY`@_=%VB`miGeOqv053=0LX32AnUn4x{idlhsan+m*9P|*$xpG$E6$)jF&`&wkTZHbJ z75EEbBSq+$S%JMMG+l&V<@gX@Nyi5n667Grt3du$&;~$DRjOFmCTl&o$Ezt zC`;ZTLc=q?eO!IHlaq4~3=79Xcj&cfMJ8+$~kZnpHs z{Eb4{Yi9@UK`z<7u$?TDebnqgHtab^_+N6eJ4dpQo-Hj5h6%il@fhYv3k814Y}prf z7x-x$$`he8X9xaFdCRotaN4J-mlA2O;Fv?G^@y0OW(R&rDSC?Z*US#QOrbInx@&ge zVhUA=(1Wv!viq=KX{m^LlJDeb5qfjB^l%+Vq0HU01GPw-d8P<`FkAYR&ZkhPk7rAd z(FGLB`1@=*-qYLO9kGuyeOkT zr?^bS^hS(%4)l{Eri}Br(8{9%G8LTaH6c^Uxvs>dDw1(BaPzF_RU+o}a`P>|^F{ba z<$BJ|xN^iX-=Ai^FOp{F?XtOz~N*ZH*w?JAdEH1T8x>!pbCoASU8 zq&1!++<3XX!|#>)+tIYfr|)x~i!)8jasCte`&NM_p)KtTnuB_$`7b5`#ti&D6EquC z&ha$Ao&dRtAXBaw>(_mN-wpaP%Tandi|7u7?*#4Oc-qT4N$eBt_!f1?x2XR!-=ZcP ztUzzS7_)hKd_x*I$}(P{oVlV7obyt^#j%)^epIk&#`ra+I zrL~|2P$MV;Is$YP=;uiPIOvxkN>hk5bpAA*Elg>bftG_-fL4N5fer;7209#cxhs#S zkWUe=--pY9F7R7@dxgp}8fmFb(%D_~P2yWYR5m)l>uu1bxc+6JD?wL*t^sWWT?@J% zbOUHR=tj^@pdW#52HgR=6SM<#H|SB&W1yddegS$M^h?kapo4IK+d+4MehT_Vxxaz9 z$MZo~@V!#~U4k^XfNlld1}XqH3>07)TGKy{e4YS338MR?zUv{#?gUYoWFE%fG>_=X z>3SjVS;RdD`Wkd7(jEpn925kt28BRtKw;1YpyQA}2kER?>Nt#?4#p6^B?|M_Ud`&)c2_8mTyLwX0q-5MnT6J*x&v43WlKn z{w}{&@FDV}^IPfr1ZLmg-gEkBPVs%6n+<1{@eIZ`ny=J>XxybSwnQl}`H~I>QTgE} z70<0`o^k+a4T#dxn7t0v1fo3d1RaZe{|m@He!r>Y{RZTwK!)L_HH``RldEfruW%(hV_x%{^`Ip>IslDBXws<>; z+J*2VpuedERZ+hKqIf(QFb+Z6ITUml=x|UFL>QfOPd<)&(QfYp-4FU1=xvbMhh^h> z)Q9Z=-3|IN=qI3iK=*>w{;LXo*Ie$usBgI#WuWzjxz>P_*vLb9hag=EXeekH=pK~k zZ=f$B`xWSG&V%ILW&0K6Uje-edK0u8^d}JA5A|JC_LFg4T8mu{x&lP&F}0ktkiS}1 z(q$WDcJp<0VRa2j_jV7~qg&9|O=ewE9IXx2ILhY{ zI#7AP%X8aFN9uX(l>fhbM!M=}cn-RM5%g=&%b-7i{s*FnDn{T}odh^|N1QtgPY`QLb!`)MfW zTS{9{&vvIa*53Enscq8S=)3y%GW81?&}S!5XHX_63zP%O1$6;+1$6__waFgL@9F*% z?a}PE zGy0DPtwFhH9}MM7HuZmbCO+K)Kt5FGl$PpYHmDlZhCjsUF#HG!HzEubi<6?7yh z2I`JH^FaBa9-snHPtXF;0icDTMWDr?13^ncHK1D1!JuWJ<)9UyLqOX=*MhDCT@U&Z z=w{F@pj$!Dq27N5dLFb3^aAKL(CeVzf&K{k6XeuY2G{gQL>cO+xqIe1@EoP)YQ zg*#21Qy2>b@XWol2zQ<~NA6)*D$uGqMV+v-Xc+KLhlrTDh=IL{m?K2Y@;TD_wooWz z#T;qPZ6ee#N7~|v6f)M$`TxZh&2gz?4{CaQeB0Z$lH2&;N~etvt906Upi;H*(n`0D zk3)>p#>*>J8?UHTZM?ctwei}@4jVU&V=>2h3)HdC+WziHa+}Sma@uUSDyPkMuTpKc zPnFwd`y$3^vwK&mHaogXwb`jvs?E-<>af}G$7XY9)HOv~B8gc>_6*6pRMaIR(Uv)( zn9;-fb5Uq>bbZ1Y>52%3TIyrbNPVzL;K7DiXhS5i+301-1=ob?)-}YU>s#uLVqI)a zYf~g)4A4ReqzyaL)kRwp;g-aLmUuWZ7g-Ls)48DKkwl{e<3@kI)S~cO$CcF_mPQ&H zeZiVUD3&nx*5@ify8408MMH>mX_P3U>*I-NvyHK4``Hrpk$5Zgxulhn#*LmTvLR9* zju}OERJbX;L0+T4j%*Bz(hpK%kZws!rPN+cT`bzvr0Tpe+8nNkAKbd2r9M&@N=Yl_ChR2r^EHYt&gZH1L7qP+LdEmxqf`xUlGjlQxm zimSv#*{4w1U6H}?rdD(pCbDEhIJUMax^d3>L?YT!6$@<)twA-6GI1rlAazWUP?H6r zH%S=XDw@KvL>1zr4N#CB2v)SVRz{m!L)3nC(ZNNcdGuF7XGi8txJDFl0Svw>(j0Cv zhN=lASRHB!H`Sn#v4$OaH$~zJMf-i!gDPZKE!s|Hv?&^^sH;O)x-#5^S}=xGv_zWGa_iB3CBlnPDzi#hm6K8k zSOyI>#S@{HL`~$VurV&(RQ2dE(X&lWR~{t~$L59V!&U2Jvj3ZscG69egd^qTbW?5! z#Uf;-W*;*??SzqdgsdBt;G<=-k0jb6*wS#l-B^-kXURwE(F6HO*2Y3DaWpUV=KfV| z3t5?3g_xK|)>f*uv1s#xdSk!#q=|*mRY?7nwI^L7iYxV(DR6ssw-Dq`W3U#BMO&+) z8(R);MJFJX=1f}~jiP0?8pCX`DjbhAv;^lw(UUdTG={@wuf*0*87xMtg7Gv_Yl^nO zdgB`T?&!HNgmHgRsD?zdjN__`gp3QKwI#yAIt=Nd);Ok1!&Au!Qyl6m)f8Eq5Pk8G zq$0Rdktz`6Vvp2Bn)AcBn0d@=3N^%y(v)%wsExNqo5X~~Q5egfl-cDtM}B61zAn6Z zO*9m%wM&*UqzNLPyZF8uG!em2JHQ8^`G8Sifi>aqI$Ac^rQjH=42j0|&1+5EK8~P z^eG=*wRUrB7)xA_jMG451{hI&2o|$jAKjCv z1T#0$hBQi0anXp9+#C#wFXU`g;zDa9v3O!mC?1ASAzT}U?0mTtwL2cGP;0Rmofm43 zG;MZSvdjtSGMaAD%%moqKtF^rW2{%7O(FG)vJLxRl*+}Z-PKq{N>E#9YO2IIs&thO zcu}-2go#|fT@bMrrO`>MMa-{*A=8Iag=G*e*%h;*1hxRp?B>`$5~X&Wa@Fd>*XLql z%I%wjSQpCmta9(pt4LU>ekWWTT7wQ=3egCqy=4eV3B~$7*^p9Gltr%ceanJXGlokk z-`IwxQqRL!FDBX{{5Yg7nmYBXaMRx10#iH7`yE2;x z50RCbzBy24)o9OQOU_?GqCG4}p3#j`K}vVzx^fNXYjxDHt!(`-U(*2=+b!UyJ$OAGcd{qpdd8W>((qg8r+shkcKsT2Kunv!I&{+91@-}orm_OD1| z-5;*rR-a65*-Ei|mnq`#J-B)jTTtedL_lhf=JJldh~3f~g?(5nHJ@@hgcro;HAOM% zz(MKJGv+dMl_oek%|StC>24cqqA_&(P4IxKP1xO)tr7hbI#gB2eJhsGfnjncZ*X)9 zZmUs**C%43rnEAyj?((ynX!9-urikS+ux;c3F|9M!D^aA@H;DW0nt?I8pCz#)mDoE+ zDm5RD#wOuxv{x>|VrjV^jd5OlIeS^8h|G<};ElHzUIJGE7(EWczi>V@;QG8$_M$CifbBUmWAuO&q=Utb%J#lrQb z=geJ!QcUD3mcFXm>*W+`el!+23d%>txI0spSO$ME9$$DX4$r8BPlw!^G`p0RMh*kV zbs&Y&q=lrc0@L)2CyeeY48vzhW~nI1ZQ7)JP#C*=7NSX0BmB=+3b#Q}3Z4`zUTaUK zlNgOpc6GTs29oeh0^9?h5HgKVsY`b+>m#>_Tr$E_q#BBkuv#r(LW5=a$ zOg44*LIdk%Oi;<^>RJs>a5Ygs!8z7^LtRUY!pB=9E$E)jl@47%7Q$0PDJVgA{~Q;i zg~Z%en{X_SM3WKil4{m79=L>IK2#z+`Ed5dda;@?9xm0>nCEU~KJsF|;cf~}S*xh? z!+4q$Gu$e7O3Rt}(r_FdV~zRfIC+evP$LYBd9!LI8k~}YK20L?nY<{ z%R(F+Yx3rY=NW54G21_`HYm4^B&4vk19#6(AVv$@MJ-1?Ke1S-SzQXdhrbQv2X9#m z=YKd>2`5k7GwSo?-t@G1OwEPUs;4Qm*)u;>#b^O)%DKxe<>o~;h3n;nU~%XO4C<-H zA}tVeuMm{nMCT|oODQGta=Ra7UW<7nfy^m|jL645Tao!37?oDqbMNmEvUXD8BEfx0M$1VtG?vYg__7l08&w5o= zm~k|ZBNo`<6B&i+Mh8o-p@(h!;` zTSw48C$Zi(MkFmxurkCR&E#TLa^u_tV`N%#6VsI2Cr!CYspM#eK@T8O-R^=G+VBug zrC?s1B)?Z76f|?3mO_|Z6+!7(4_Z?YJlLmI(6>t~XUn1k@wbA-SP8FhHpV6|os_cf zMf9l2^2F>@wr*eRQ>SLeKFP1H$_A~eUs*d6$ze4`tC9K=BZ2?D2_Z`nDH;#T+6col zN>db7idng)C@0Tkljq4j9Gi2Ba+)1$V(q#P8>4B3JDR^=DXE+ih>6PSw82WWyUE(~u{J*QLrVjXP8=7_>S_p0)}vohOf=ctF6zq&_2( zP;%p8*GE?F#vYZV)I6P+YXM_uGD*2jo5w=+f*L!JvvPx5bXvk(gz4TQ_~tK@1m}_O zVq+AKRw~j;EN;Yc<4P9XnWreSStMmmK?`6kxa6Z4_fpFhi_R4r;_HM<-B66mwkC6# z#ZxsZjt5-c7;ce0lTvRUDb}lEon8^)MiJXpl3g!o`ZRcL>AopxAd0mq7h;{mcKeo1hIa0>t8Ns9hEH?_Q?fpg(!{Ddpn|i*=pfsoG7hnA@&N>TzvV! z!8tM7LSyW$n2|RVhvlf1r4i*u$TLm9%kl!+vL*F~eKTdFQaS_OmTH-`d1K>}-xv$q znoq0Tw(@y~?01{eI8)r5G%T(NrSsC=92=p-qLt1g%_OFB(kd8ND9^}}-YHwW-8y(Y zPA3spZhH4Gn*ghfXGm#X#IERe+>c$|a{aq(!X(*{&7o9dvECN}#tTbKCoOASPBYU_ zz#5dxigc2h#a71?**#jRH3ntKzBZYNXkdk|;6PL>JH-qF4S z8$F)wV9vUX#ccC273Kj(PqzCcVsdk~A&ot`9IbiN5){u!m%PLpm2-vpxiP+Ui8WNY$EWBS~D?1IZIol&yId2$k? z56*;O*-F|1Iw!h`oj9q)X|Ew~{PEMW>jLcU^3gKwtPaO2u+?&7ZL|SzPaAS9_msmU zNUNh}JiwE)X^p(xct~y|(|5)_ok!N{Qe-#n!NpsCQeS>uh8#id^{!kkd2(`zasT4e zg5AR0%lOo*Mq2bWaz2}~B*>h^Ek}3yR}meRoLl%@#d5CtRjw?%B^IsOaJ_c&yLDLt_&jvNODl?K#MSQv_>lS$m<;leouyx>LltNNIH|NpP zo0)w!2S4FUCK6P(`T7)psky6js$7h%_o#Nc@+q=#T$6(8E)T2A#m&)aeoi*uQ3k0>(H%BL~NhC%c`_%$x zo6^eTz5jBxGBiR~RH!LTdliHBJ#yzQSH}MLVzoX)dNPwj^`%4N*!y6w4n1-iWfxQ5?xA1ZH4gyvSa_2R&<$j=UlNPL)z?S9a=Ef z0kz5loMc?hX1uT0EQbJbELR+pA@y=BO?%iivSW0zVhg)QxR(^RTa@Uv_SMA(BPf+U zmWTsPu$L5j2IjWVMr)i5B9n>pI?T;{<{1`zzdFp?GHBN_-$PPqY-U8e!ZA-=ZCc?q z)_cIhs!IJ!7+k~K4}rK)&nLs*_YlGbg<*G2Gtka?=g zq$DM32*(raV_{+bQfxs3HvPiLrX@+0su@j5oz|yOO--HBuZc}gofL2NYuY9^dTss2 z8$+#O^rPnc)5+BDl4VDd(L)ZN=!v--ALNP%;?+WW6&Ov3-rdZ#c6jEQf5~Uv`BqTO z_l^Em*gP_Z_TN;(H1t-u)IlTN&lq^Q7=R=$8_ z>lGVZ>C8sHBppaXl@nc$msyPA=3l`&juJ!bMrciR+45j2ja0a~HL;nx|G3$Ai^7Ur z?YzW!6k?DFcrUaz8gpHT%IwM^(z2FLpTqfpUaSRk5f~i6AzrW*)f7QyQh@aA%2}K= zba1P5VEMwq`cQLgxCJIX50CG$-F%F{=!P&(EW$Y_wT(C)r7_x6Z)8?BV#?Zu{uM7~ z8@;VRgZyHxkZ?ptT5GUXfEv*dRoaTSM^%`enKQDp1k8B_bY{Ww%_R)KOT$O5k5Jdx zO964QCLB74t+B=K*cyzp!c}VYA;=njMe)U0;f%*|c9GUN9Wx_t%96JR;GT|bXx1#t zX-QI)(pfpPCs4L=XZ92?_A?ZS>{+>Db9Y~Nj5z}l8ZhgDM8&A@5nslK$MxfUBAAbw zXR4}2se^hPT}_dd052PwEk4hR6ooU(5NV~LSu&|3%8+8keL15yk#$Ft z@WoMa1Ws$X&XAE2QFN<9W&RZDD2lX0oCSi{cU9H7##gp|SFAbe$_vsvC7x1{!7G}Q zr4X%v4yQ6JvA8l4tE1zW%oAa4kIW=r2`%afs-GJeImli$8WZ=?7unDefapxw&B9Zq!9IYw+L@RfHxKWtUh{h4Kho0;PUAnAfQnTOiF>$R?#HPP$h*@8SNb#H0j=@sN}tdUVV-o2Yey2aK%=Z3@}i3{+H(b(ukDl86Jon;qc&m*?8X92H zBmD{yH;-?W<~GPrE+J0y-8(7FAch4zNA)#tk&~&^p}rZ)Ey_4e7-!u17`p}GP;zq8)z{Y!P#@0Y24S>2%e*$ zE@C+FF1j(kKi)QmS>UL|I3~}@Q&`h&V?+u`p4|le#OfN+rNRxhG=UQ*e1&*zK)Za< zm%;@QH+;L0I#swnyf%arI4UTO;oBYPlJGowd|G9~;})E0wV?UK zth4F>$C@U&UrQ_~&Myk%bl&=4q&}YHezi#wblA49tq9!>tJP-ua zO1(kaNz86iT*6nUUU_)|-*zVwG+O6Kh^K7+cIT27W$|rzF5&${t+ZT7a-ViFWTBJa zB^_Vu(tPr|awd?M@a;uK;VFef@5$>)6;DU)7@^>*re~V*qguU`)7S>Tu$fIQ&)X!k7s^X^EZ!?@$Xu^DdhM* z)zALi2@#)rH8j;ozf)3D ziW#Qt#M5u$O8SkmM$&IWv`(;kmGmt}BuhkzwW}NBbYj8Lu0|wMSOrbLI%PVmr0G|u znXvsu6)oNBC(^&7na=Dfd?#d{)=?X3Xh*+-q32sDl2R#yNc!EFOen{@^bO3M+R3(* z{s3*IQ(98`RbZv&cH}#!^i+YI!=!(ILf+~K)9>D8I_d}8od(@td&_6`f~iJ+oOFbz z_`%Scc(iGKBD^By7~)E>(tpLsnr^^?UoOwhd0WbBC`rWB$A5+6xdw)8dXkfLfVZ=! zPK`YAX^M*;r5*C3KWInc(bQ5Fo_(o2k@jCmvu2_=sjNA2lyHMB!bY8@l%p^$GR!?J z3tI4?jAj;iWarY+(lGXa;FNYT12Mcqo&$%=K#_)T1xH0E@J&ECS;EHLOE115jB4dop43Ym~DZrHT1TI-U_IF1qCM)ZCTPHo359?Mmm6Tv|5vw8dpxPrKmM z)D^F^Ur{y+uY9uFvK{h@^V5?Zq~ti4G%L#upEN7e1CPgxzSf~S-;-q)i?WA4S-DK1 z6>4Mh+@dM9(!ldY--5;Ib4e>wi>y@LHlAzY30+GZkAR!2BO9WL7448+nY7kLzH(dm zigX3j&T*CM1NPjK;>g$ArR=iB<`1#juZ{XthY(zf6J%+4fRwIH_&yTQ84C;BPXl!Q z8w>G+0A;+g?o@pSpzAa0EUR&Qxbd*pV^G-VzOg!l4fML(6W%(V7h88-ov>U;D(*<@ zE^KLY%Io$QClQs|>grcy+vxIG>sq)=P+VN`S~@RoXGo6FG_ETPsCZ1B`8l1<;@ZCI zcgo6)bt9IzA=Sw&vh`KHDw#r^=yV;PXkRs9+!jYhODD9hD-?w^#Y6#h4aFfv8c%se zc?Y`oB=WKx&N?mg5N|ab%Ym$`KCiGGkCZ8wRn=};uiIEzK_yA$bi67nA^$Ye{VBbf zisw940(NAkRVD*ABAEcE?@oXr5zO<6ETO%!-6s|h+2}@e_FI{G4 z5?w#-sUPxOrDeP1MKW_vt1#xcCUvYh4E+^lB~dh-R*hN-S--k&-*fA-=Su5dgs9~# zN~`J0B;+S*k2uV}9R)J2K1oY=`FZqnTvm-scBOVn#C-66hW*AlhnDLrCbfBB`Q~fX%&=Kfk_JL^7SO?2enQc-8!gQ?A|vwt7|<4QUrG) zHjxg|%zdSVd}TtL1zz=Plsoh*@Re`fWW1FYP8BV6m?0X&G?$>ytjCl^gsv?dxjxjA zpl>;gds=`E)YjM8bu(9|cy%LOXtYJvGqZQf(Knmp+NrB^5y;xmP0NI!cynxSh<3yK z=O%<`Rk4)T#bNC-)n2HHtpIuU9gqu4S*jrD^7<%sse-n{r=KG;D>ZyQ%6+Lxxka&? zM`<1!A%}-YQM|7xHDje2`O1k_tTZEELD`7Yk(6yXokCI*Rt#8k?Tx~RsyST5^4KCW`>UOp0rDSF<;}ecJ}~ z7dFbOj;hNo=Jm!XKAhwU99#Dk&q2ym<_5U5i)LKmji#UBm%JMpyxU!of%?p_2 zNl^s}-hQX7h_vNU-BgNeE{QCAs8SWz<(x`Y4$RQ3?J|mMTU!n(D<)RhKa?tG)#K&r z(LDxfJG)Yq!RhBpr3{zb$~C+76hrY?r7Mb6dzytXSM16fP^;znE*Dj*wyDS~zLQk# zKuN`plT=pd@JXerCLwI?{7R)EmKKwHSXQdcoxZMAnM-M_EUDCQilq z+H6Fw!PjGvxT}P>&>%*VViJ?Ii49S{fO=FvYd1J%PNA>FQ+#}Ta4E7 zu8A8L&6W}Cc-O?uBP3du`s7(#e9=POlT%M#w074Q%H?^}_vc!tn`;>=U1gTP%{7mc zC<-fFZ7$I1L~|{jRR5W>O^1}>cAdHA`8xNOYl7-=Sh;G~#uZ|Y$6U&*2+|`pZhgEd&faeAkXOGh! zG@c%(a@}qo)#iMCJZj~696V|}cY1deSBb;5qqZ$;Rhn@7ZPZ4iml95!B1JuxGe*5D zu{PFuV$@>jgyc$F=`H%KF7Iw*0Z8}aAZ>u*y)oY^6()|S4Ws>ynUH+1!msg!7 z%7oH;d8el&X`ZT^MD0M`rkJpOBuOvrbdV&~xO8`@>r3yQxI8H8jLlO*#eI^N92QVX ztA_J4mrsg=LQ_tc*Cc5hRGc5m@-wO7D@l0unbiJ-N5kARleE6r_d(3*RP){=i<+K^ zq}d7~Yu8RvHA_*;L6TI>rfgbe5OZY9HIg)6Q&e#1K^+`Dc1BK-q-~149H#P<-Z}{? zeOby(&Hgm0>dk3{bc7`B*)37U43p}~O29^_4%{9+$+0VGS*6p%d?z?*|06{)>Z^}f zy++DnXxnLA*lgOGZp!8FSfLv{Trw*iYd}_q?VPY2BATlyQqmiuF+f{}mYeFN%5y1d zsp{4bQ%!ajq5&lrkxR^^1)=4orXVigho&>uIzH6Zm&@y+&as>>4;69xJJiL5>g?#R z%>Uh<4%GskZVt!hAa&~P6qB2R{BgM%NL8wH5y_i?)cL6GE8)#Qp49G5KdK__g`e2$ z)3Y*)@6$(G==b>LijUh_uAR_%sLJGDPp3Ty$M{GaXHW1K2%+ z48^JMa%U39My>VnIic7b>kwq4N9Fo>BHCP$NW>yI;16HSaYY0}CUhXa-0g+yMEW^6 z4lx{R!45%Zc0mb?;}EOx8Va2{y^LN)L~Hh!loCVq64pG{FN=9i(NIEWF-)HYH8Gqz zDP@N1WvU~a!cF$IdAInw zs36XRi*B4B4%IITw>01ts$o7NHI1RQ36>e)m4Ww(!MTBYd-}jO)e+Y zx7a>;d`wbt*D>YEgG&QKt-8`T+%-<6VXmej< zjZ)$`+P%^c5;Knyy&y)za7?Zg25Tjh8rI`}2hI=EiqmJMME56*YoMQuK=lf6*~WNn z7L8H(7tvayb@(cX{PKtN->));Y7?MCUCC&bv(W? zMten<6umx!iJYO=i>n!o(B=qj$Rm!c`MlJw5ZlNz(LVOy;%istS3A^rnqisoUFYHO zgL$FmNYiE`-~OBaG6p!q){J#6fh9>m>C_#YL}FP8r`U^67=#lEbj5L0sZ|jA%W<*g z@&JP&J|c-k9ljtC-eeTH1lCeP`)ML&0f%c4Z^4Q+Qe2?EF32i~qMYDb6as_w26X!| ze36hIL13Cc&`#=*sD#HoZYU*lp!33sx<*XA@LECx*^s3&uT*WMIUHS&LqmLos?i6b zt@sw?p!MO{W@9g()bhM_8#MaNv!+;dw7T_0roHv?O7)sEGovhRQFBo<&L_oMt1MWi zK<{Ql$(@JqqS2w0MsM>kEMyZnl@?QGoYHCx(?(l`ZJ~9-(Bv|BJ_bAF>sTrAEZw@K z6)Cdo<&mWv@^Fh{!YS4lMo&jj9K=4v6J_NqXI&-!0@1Z=u_7~uIwb7mP*6A~FFYuj z$Od7nipw;s)gzGaYf)%{X`Ak+v?|z$2zm6o{;_?Bu3{6 ziZzfY6&{+Q+lVKOVt1;#STr7A8$yviP=rR)>QKuHe`uvKz@4E;#V-u#vs@L$p8me> zbTr)4(Ae7zh~i|HjJPpU@*p4QEl>LN zd{F|uvQv&cgc_+4PATCf)QAO~VsHa$gt{*bZ?+v6{ne0V&vJXuU@c}({03=pb4Q1v zPj131Qs6KGZT7q+BngPNtWD|k=;6$nG^B9mjK7qeIpWNjR3d5QvdZY~$fa(54BwE9 zBn)Q-t&L&0sE)?v=jxnFaQSA79r;O+-I&e-JN3dM&bk#M>Whw=9NgZ{TwK3$GrlNf z^fCW(*%#fKkg(!y+oIAtG1G8_M)VMRc;93zjlLd?ZOI2%X^;|}R}zXa>pdx)BK0bx zr6PkUq?WL8oe|30crO`|nyBQ~Rl)N5fV!=kpE6#rR1UKT>z($B1J&Z%)yt13sNbgvys#J1P^^&E{_K9=i`i|HY{-jS z?UVX_e^~bW{scXIxr>MbM zlIx5TB@unpqm~Y!6GJHqFD^DJiG;Jr$t0aO(0>s-6*r9+$9KYeFn;N9dUiG47@)=K z=v!KTU_H8(mg&Y|ZA#NEKi%l3#Uu68jX`=uK6sjL4AjDy*TWg%hyFj--u%C<8_5?v z?{?yS-}l6hv!@eVPI}Vgxp&5v?T%mDiN{is?s-4(Ly45cHbt^Y%1i$G_pJ>m;NTom z>HCYsgDMn&0#GOv3I#m21shOPjc4U;^|es$X=k475m@SFZy zNN!@qygU5nWm@!PvdIr66PpnvH7z;=(jjnj?pi0g+#5JpOc~;U+J&B(4yt|VIpU#u zwsOC^?3(Tns26?zdysYGM-5rYG(ac*+-yG-91-j62C(&ZL*ul&KP*?k_4kD$#{KH! zQabFu<2@|BvoLo)S%jv2un>OU4&^JvJla_ zW?`GPlfGC~vg@v5hq^}JuY8A2H+R0lab}<9rti?%yV0gJ2aj-L81|>d4lSY;I<$ya z=+H7=m}tI3i>P^rmXS&wTEr}MXc4j0p$&*EWPOJ=)dSG3mdT3puCeYB)PNI5*Orjr^*Ja(GdqdL-*_Cs94v zdbxq6b%~m0M$b!+x(Vno?pIC)+3Zexr2B+f=Tr~}Q*M`m%Iq>wE9=%aN7jiGx7tU9 z`<0Wz;hw-;*!RsFe(^30z~xYRz%7L;!_Up2<_ai#mcmtT{V|H#X1Z~SaiYE%ordjK z%g_x=&D~|OtTCx9c`u5flsps7yU#fiQbGQ7K@T}_=pjoFaXs33UQ+`Tix{h*+ zYymS-Dny^qtacW?u1pTWJ3bK3ph|F(%vmV2~>I41Xd0@jUmY$`RIA< zODAsnB_V;?3hRf0M=;Jd!HvI7wO20tDdovKUi%($D9K3Z!Jmcpom)65B<;t0qnM8-SSA;Tfoy8v%MkiVwqP-DL9+YH6n-;7}$(A*O3 z0w-^?LR=@fS(hT+uRJH-;rM;9DX*ZwG!^*m%c$ch&)bod?@qw>>XfK%HAT9BNBnoP zwS-}P;ACq7&HAAo%le|dh1wr(IVu$B`ovAGI$|P_V2NcHji9Ev`H{iI2;oGAhvypw z2h%=uQquvo@5-gdK66sqWv0GzP4y7#BRA0;*!rdnwLU4=So^|F9!J>qfzy~HLL!=I zbuz_`M3W;qgu!+59dF6^24SwaDV-xIlUp#9({7;UG$OklQ*$KZxtrHDurc1rupGy@ z--2RY(9$052RFU)a$IM)QJY~kwg#>x(R$UuHN~k*DPM>p)umJksU)Qec$t(cVOU2r zFi2}Ae0nOa(V{Jy3h10jgb4pJz-s4u7|# zdE&%$C#VvTal76orfqC)02_ZB>aC2ePX?y#IO;44u6C(p8Eo}8$@k!!A&y^q-FcTp zkMI6Ef>{Rrgbi5JJp`oQC5=AkPaP%M!VLqQblzQfap7oyiTH+=knUG*e_0|k!%1F` zZYf!{+(vg1esUOt8$j?Q4WrHv41?&9D}i*p`CheLaj^M5GbnM=tv;a^VL#*LnPsvu zR)X08E7ej*mmiu&(haS%QLDA;q@r_-SEe?m$hir>x83dtzHDIJ{mLonySRRe;ig+c zx279Fd0BucD;-lTPvoRqaScd}bo>a(HeDS*3}$RBfQ*ZU`Y97#R~tRY!!wbG3cX*s zvmy(J5|(z-A~fwKU;7fZ*iCN!6>CTRYA9edRKoUf z6lRmh4bKF@`l1PLeb7{U<-MEc33{i#YA%dmV1vcGIbbWE^k9F|N0@N;&T)N3AHweW$48XvwKr2Gm!Ad!Z}b zp-VHW_Q_JX+BxogtC?=>B`1rT(W$%K`Bn>}^_x@6o3X6}mqNClT#6UkrEW9PTnpE? z%>z4jUpCFA2#G4-@*a1yMV^;0h$v)Ek45(e*0M*WQ(#hwI-Rblp zk3b#h1XBXCE^~s(!>yAVz}77d_12E?lF7B%vEFT#T|sg1jVK1>E`n~z0c-#Ur7T@pTn8v~!MZF*9HsSAws5VAm4z%1F&dk)EY&zzr-K8b zy;6?d!DP2PVc*7#7W%rB!8)PdK4m}Vct*)F9%qFq@P2jRnS{8(L?IW>;C?P`>FmhW zT&!g!Xc7V#LZBIk<1w`%NIa%CjF)u#jkbZ!rL582Khl+&Q79f0cvM1w{|GK9V1Oh* zA8^+wBPa&$PD~#RaWQ-L7YJJ19N6yTVlTRdGb=)TO&R*82R!diw-E;fdvQ+X*kV7= z`Y-20(v~DGMySPBLSnV_I)fgrQnzAo09UK%FryVhYGRUeDRl(71c9AJ5ng|o1Pl8D z%p{B^7S+Y*7D97zEiBv{wi*p&)6kjNL$u<#P;-k&TG36cv~ZbFD9c6qP?=cb+mQ6i zYh#rjk*hN;`7h~8B{ z9lAyuY#c)zmC~XuHueK!g&32K?N&6F#uy%r-*gAljnT$8LvUJO*wpWWZRmU#_RnNas%o%n4 zOGP;8_1DV~+df?@f~99@Usz&-Y3=12tLFYeL)PHFeZGW1hG!~rdpzF8E?@7GeY3qg z`(^`=?@|vimp@*Br9Ay?0a|3>tp%9G%1;*H7+*eLh!>b3Txx7B*}59of#hBG0}FQS z#>NIztKiK=M9KWpQ0}}tdj-dihK|~$J1zsdq^47)Sg8z4Jfn&o?=iXK7h%anD-I7w zONYlIG@X2l+OS|0xpHX~eOltI$FZsT)e?y2|I{!z9a)>wi;ABN5r||sTTIXf(;_CS zJSYxiS3kF}|7bzO-|pfnVsYj~dM3McYTJgeJ2+J0Ct$oo&M&lZ>R~= z@g&IUua`wvzAufh9dUPA`mtxeTs8}J)t#l0ZPtFXY!2(pr88LXF3ltD?v-V07)EkqIayx=L1dl4-ZYx?ic%&;K32)pO_t$6%Ax64T8O7(D3MGh zdU5O|lBtABW2VeISHCdN6Iom$XJcd`qK%D(ZPqdIMX}dh9o<+c3%iKhG)n>o`eTTb zQt!52p10*3+MWB!qCNX#TJq0TdzBOJ$MBTKLj~=jJwi^KQ-E3#bZ!VKyDOpo{kXwP~kTV@aO&A z4MpgK#2Fvmah1a);F^<*_$X8+Mr#+Of8aQqR(?G`*?z}ns}4l(Ne z(i?D$QdndfVHQZU#FE{9ceXdhNymKW8BQ=nZ#kqYX#nG7vBfQYC?_de8 z<-iN1T4?}u28i|wt!S6tVCX+Uhz^eP$6=s!z}1LR9w8gfT!eac^4VZEe=(lyO@0N= z_zjKOBq5B{9`vwB<2R#dS=Ass7*Xvx%(|xdXP*6|`?~whunVuEpEmvhNq)aN^$eb> zn5rD*@E076!l;v_bT$W5_(>zw%mkg31Hpyu{)5>B)WpdD=|YqTy?@}AT6Ojr8)E_^ zx%7_;i5;=pbSRAZ3&_yw%NC@~E)-aj1{MMDlQv`uStHRftN&=hlepT?`xsvoHED(b zuzwxQ|Jt2D81)`(Ac7=J3iZZVy|=oi%&X3ZjGdryPQ`jTO`Wq~AptRQSp-AV+u- zeY~Yqj`#%=M|0INFd-jrv|#K_ht=8VYVLS|;BxavuzQTRt4oDM3F-gmCP)V&fz2k4 z&cku<-FpA+e2wA>Rd@H3RZ9E!ePtQIN8u?Bx}>=K`_7BFtNo#5-haWdou3p6?pPX6 zPu?w5cP!0utbo@cE_R4~RccZx#|u2n(Vuo6p+`EaU5Z|dCqPO~T9kPWPd-3dDRx~c z?>coshx(xU&m~(IvvgKD3^MHNsC}D|G)S9U%Du9`mQt3i%+E`; zjxQE)*jfpZTNTGvhDt{tpDjUB4loQ>G%408>aKWAPn)O`m_;**LGpA>Gzbzm(7S!8D;bKvj5LLn9+Jw;JIXW z1$Ib%ANJQQOLa4)8(I_DUVYer!WAT6zv@;4#(-XG(#~z7!Z>_p)l?P6kaMdK+6tnM zyq+P%X7JM(c@Zg?m!+#21>6mTkWhz+uyhDxJ25b3SZNe8ATexZRw=b;Tkq>6GTCkVurK1QBD+4W03Zw>?kx zhQk^B82Y0qKLTp6`|j!Jbr&~_L?H>&(qo8>!jnU+Uj-SOpfD&5VGmj#qmU-*h-p6u z;ms*MYeWJp$dy0>-LQ=y+}3k7mUP~stI{flIS`024%e|>0Kr@(PsRS5_ITBCMM_HG za1^|*KNW|9SH)*6q_3{!v~6u+U8Y`+t~>-)$H5@HS3#a?=P9scYQyTmCRB+?L5b36D2L?n$hK1)ujU8TEH9>QEMXU3}@!Kj$-c?QMZ1AejZH{#| zAYR+C;&~UqJv56O6NgIY-?@f}F@uhY=;rBSI0&gRc#bU9+~iY@wqp zTPS{>wk>pbKy*~jgreXdDf^T-+9=+#?pd(31=!1s{G62XfI+KMFqsOM?8d zXY8uWbtHST>|7m$*K2OnQ+HA1D(30-7!L*Atiy4St3Q1@3Mhp#`DImz^Fx%I^@j8I zt3$z#$0M~PU(1qV-(zDX8?Ip>(CnIt28}>mzTsr2yV0KyHlbn-w&0x&8&J$Qf^l!q z!=o#PwYD>!&NuOZ(v=!gV5cuw38*M8K#aexg_>u8VE};=+F;4l>v`fX5&}m*tbs=e zErlSPq4JJ1N)_?6huDx~k>qlCwp%}64O!7-JjOVG z)Q8S7m{3nwrvs1}!t)~X%92<==8?n-rM5SAY0N=3<_CDEfNArf<{Wd(!ueoA(m;kC z%N!oQiLBYd%b0!tp6o5EUWyVPtXEsMuqMGFUGX7I2=e+UcFZ{uLLfQtXfPwqruTqG zpp48KA*!?!+uVf-(rfh$wfcNqD^8TXU|bZ1i)RTFqWAIoc%Ol4Wb&R_%1}rpBKUw_ z4h8cd6Db)IQ-2{O{N}3;LMp&N5gsq1%$!Z3(BJw)2*o4|Cq_0&#!Cepfm}@?a+;up zRu}8QXI$oi=lpbKbxi(0-a_0FTn6!98q;1tA`CDGIh&^K`VW}0AQ*j00^S|N9^FEJ z#u6$rd7t^T}6dJmQy3 z^F)ZAH`P(W6u#efA7M$NBLvbzX-KmTM)}BD0v27b(#HwW=dvDP_yo8ejwuh*%+Qf= zoD&QIh3s<@0@}Z6UV_M2!{Dx$OJLTb8#CL)DrLrVC0kwW88K2L=?xaYFX@e98&gsx z2Y8`(36fIT^!{Wz-X&IYrLK6oRMj}MQqn1mANoqVp$3PObTjRj6kEUFRsz5Kl`xb_ z_-SuWDw(jmMqi=p;d$qCc@4PUrBpoYljGum@*&*uoYH3-3w6+OSCI|y*N9nabJjD8ewgF-ShjjD4yGOM?hIYbj zFyKpEf1V@o6d+o2+IPxZL^?rrRdCO==x9>_I*p%AvD67pCZ&)Ec&6{BmiN!SF5*)C zhSvd!g-^+?Pajf%iYZk}QRKarGHh+$pWx(N^Tluq`hL)%AAjmRdi?O`zf`Ax47&}y zq|M9qhqWa4`Z}v!SL+zja9YToDLFUl*-gt~`P2gE;%}DozZ_r+shIepjIxf|7!@Sa z{jdUmwG8gl5$!i7-93H5OuVMzMLFL>c*V=%N>7Ob}9LE9zQ8U~0iAaU1V^O=8%aOOFZ5W{T{v9Vmr zNX4<@1`=mY8g)I(mW`s@1#tAdFw48+43}U7&ER2z1?K3P@v+7o% za%_5uqp$jWF^(B#^8TV)GP!8b{HTfAQ-5aDibO|ojTL7yatP;UcxXA-hH=PtUaD_8 z_o{1!st}4yqO%#4r$*kFP~g1fymB*->y^QcnFsM26K`?P>W|JQed#+7Wm z1qJ*yic(Zv(jV;KVuy-6na>-9Op?KYs5%N2=+EJ27+WQ%YxBX@7Qadx z8eo9&q`;y%)$ze-69yR6C$PvRui;JSSRn?y>~GVmink8om^8-&(7PQ>Me4*Zo&c|> zb)IpwfU5ywW;^E+ajON`QQwrCZ8%cKXA4n`*arcVP0c!>T|;g!K!B6Q^i}ooA}p!b zg@E?U%3W8;wQ{<0%;);9A(u#o z@&v<*MnkCj)S-t}ZbJTknHA)tM#NZy>as^dDR{9Mbhx0SP_(g4p1)he+uE1iM<`XF zY%GD;LdM!d^`VE0lHGwh2F3t9R6bwF>)=;B#xCoQNZE$4!8>^#7OAorJ4u`2F6$g( zE54m2K-`Gil&H+QcRu=(&eqm&`UfMxW%tp62j*HIF@)HfU7hhDoEGk3p*;Cg;zg2& zBnj>6lPn>9b@@jqqM-ICocDLloZuB4zDIgWO>IPr^DHvLW8QlYRe!cNf~7BtUhnU=4nsHPbU0tOQUvp zqX%oKOt_WhGs2K22M~YSN1nY6(xk*d`}OkqNHJ??Z_<8YF@|gGw_1O!;kbNrhxN4Q z-EC&@my7W`kJQJyy1Nf#_VK&B|12x}%ktlQeJDbA_ERxtEDfxm$txGLs8eH<4qWj( zqw%pEYKLab7UBz4ht_`h>DSJKXV0p`{OiSo^&hI^^7G|Se|h^+Ypg5TQiO-B?#mv#M?`k1)*tVW?K)NTxhaS~=pNbpdgE@~~Pf0__@NoD6 zOLBGE<=GxHzOVKG(uGbOdk^0|g5`H_nC1}KT3vBO{z)UvX&t_*4C7)iyBss-AtiJ1 zz7+zhwE~AZv=xbGQ#U-hJy^76WT<*MexqZ>SK{?}uqpgH$vZ>0?Y)pCsAR9cEvLhw zc#c!lgp=FJ>6LIl>mZ$Tt<_{cD4{mHV-c`?*FTa*w*7%O| zJNwUnf!g0O{;SpH36NlZN)Es>xI1KM!32eW(9H%S5L+}zX+*6wqwt6BAaY^02%FSeRSIM~&k^coZ#U*yrkJ%|+?9!0K3$?_>kt^V$yTZlxv<~} z9Z)98LnJ+4 z+T4c4j=s|IZD`V{#du=Qln!a52R>E8#uRIoj?e1zIvaCOJX`HfK77kUW0qmZXep9BhZ;`!ff&L zbTF$9=pO%q{12OGb6vWarNb$A!bP3S0KECHE|pSg(}xPMF(DMd_^^kb()1nN`w~O( zX_unr2rG$(C!`pjw% zAG23doV7Eg(CUptCgV&<564eutR|qrCrVI(Lpx}LE`&oJLXuLxZ21GAPMSb^mVIaq z=U%VKP4R^NQf=>}^jkgaf(2jPls?Fj)X6O9*w<AnWYCSEjOsMv#!6Aw z8*$~#uocXuUCL16F;(7Hw#LgTEqNwL?}nyyX38^}fHKxD81Vp=^c%HwVj&4&fgd#U z=XL!N=7ilgmeMcgV5rFmF^ki=955l%rc>)L)DSQOC-drzrE>1Z^f`xPVW!@AFfv6Kxb#(R=uG1QhF^7WlNh;Y6m_I2U zOJ?>^r6ZlE7Hy&Ww45H!Ucy}cXaORZaDXxxDL{IcVu%p9T728%I2R(8+01p?@77UMcPL4+W0F)5&@I#E=dExNso^c6kgII zfd`0oIKWk(esv{5gAZFolHxgMR{RH)sQ@s)?P`?}I;{4`Dybe*+69{+375~vpz<{n z;bNA_Q+>nu7~OQH8Yl*fLQJxI_xJXhfz3Ss@jEhgY_wD-vT<=K{dNaDH<}ME* z4qvIzM}9Sllsmdt`mhmU6%U|8Ev;@gVxXfZ5X5&EqpU1OxwjbQ+ZL1`;2cKsr)q8x z?rYMiTno?Gl2m=t*kFd^{7UG2+l)t^6zFa`??H4Dn72D?dVQ(7yPsTq7FT_@Ad3$6 za3CcXvHfRb3s=jK5vv*2uck322!TP@TM*&*hnd|lHp`s*ayfkAS@Xn@RyKDs!$TXI zhZA~~ocF5FnyV!kfmU;!q|VKCVtAm_Tqm<5HnUd8irUO^HcThD)k z1i{0iLN^rQqCV@eI)kfg3x|?s-7mgL(XSR&&Cb7hd$5qXQ3%qCfZg%Jp%!z9_}@o{ zMWRGILAFIz^Ln9p#0ho}P&)*-_*TXr+4**Ugpbn}g>R!JI+w@=91NMQarMW=#2Aqe zNV+xAR-#Lq;!16lG-B?9GOZ@vrP@X}kC$p2A?~9FGClJdP->e9XsK~NMsZIC#$}pN z@QkD2HFjb7@mu%;LC>%9g)-!Tn-GR@KFd>ZbbGj(^{(PQ#^uCmO)pZQTwSA#vR-S#wL9=UPz#&vfIv`$1mW5AwbJ zAb-0bRDD4!M;G8KtOL5MSS8D21p-)_}1d%dJ3=Pxn@-2kvOy=F) zF~LH*U8lHi*0PvPvPRUzX=4tlel8%Q+ful%ny+MrGUHpRVm`_Dt0~T-x3%3#hVZWX zC>sGOf}UjM8nhwJApxZ#w;RX=4E8r#h=tV=-sdf}p1|_>tAy=sYC9DvM*%H#@n9ItE6* zz@W~Czxmt%u$#}^qgE=_C0>w9N+eKvuhS+FEkVN}Ycqz~oOw=`Xi#%l1n>lB zndQ+o#&6>(f`|$heT_J5&gR8DLqTTJ2m3uWNt4}~Z3#8J7`^Wydj^tKn-{u;m}2Ix zwH1vJhe8?gD49s|E~14b(1ae_F)~E&4!|O~2xnDPxYkSrD-GN|N|lyE7_P%iWQi|p zlYHy@QyY7=k)Uv#Nj&S1wowr8i3$`*Patn%8obebUGE|#=+UKxwH7F5MzE=dgeHV) z82u4PR$8TqTyzRsvGU;CU>I_)1#LaVl&Q@+gfc>OsO)f0ZDC8)o?axh1LcM31$P< zgeC#Ay3{(zaHJNzhxWCY;2Px{EQ=BdwlHLBA~wwtMn-K`rg)8QNYQw_FDNn$``Wy~ zsflfyxtD9xH$!mZr`A0gs<5v%q!7gj`)4k!P9eZtIrTaREGeRf00k|%n_S~ghM)(5 zRc*A)=oFr&YLsuhRrA9k;?yNvO*{nTFbHa+FQ9P8Hd6?FTI2AHEfi%AM_3z&BbIRZ z6d!s%hTRVD<>C_494jf;(>U&z=_l;JSSwg zdo+Iu+tmdRi|30_(ulU^iRqni@=#rEz>pieEkH-(gGRJ>Kk{|v&ley#TGyLUCFcG| zt>DfB3eS%nLb=s)zgW7(c%n8m;x!NLpk$|wvMwXDqk6@sjjAKKM%_&+)P~x5f%{N& zuYDg`*7l|xx9Qu3rIdn_|DWHJ%iT+O^snXbJfh%y)qnjiD!P^8`w>t6RSH^@g$Iub07c1N7e)2bEKA5drK3Hnr59n_OiE?>B7&XZrY);miQtdpsI!W;>#?Nb^_FpZtgk4B zwTxQLhU~F+=X1t9#)SohAj*?vi4j%R6~@U~XVhw>NYbDhe?2rd>sGM>$>OE!V!bw8 zP;BDOGAYk}*)cdu9;k!)A#NWJIr8H%At-7#423-QROzm3H)j&K@KMKv<`E9mbEcF9 z%U4Y2jZ!H4C_Dhumz=1 zJ)MHBnWUZ~ze@GA8e~IQG_~b37(e#F zkmh-&gQaCyWn)C8YiUkMpNTa=_ASMFIy9@FuENbkbs&iKpoMDaOI1XdLA6RO;z8`~ zmH{k{%R5=+Y@vN3t()7gk{hqx(4ZFWy40v93E$jZnnUDQb9V_^sth#?(*m}!cTr7r zBsR++rJaq(FB|8N$5(;XEJ*6eR_}$ZkuF~-+maIEIBi}C${DO$%ke3W*=AXtl#`F# z<{2m1Sf%AalsMOIT4Dv&$t5+^H4kKmYYkS7rZ9&bGCZT2D&eq<WpbJIN8s8-Rv_y|VRB8r7F0602` z+qJSWlvHdJ zPXdbIa-DMHM>v_m1u5L8Lm0{F_Fx1TsSF&a0@vT?1V~&VxZ6Es((Td1*wO$Gn1jjK z>11V4s_PnV1Lcar1^CqKFo&$CK(XKfy?DVfV{J0W*Z^1RK#Q4M%4o2^wE_Q*?yD8a z?>PLe5%PDOj@Rg;js*sSCV5?8b=f;BfOIHeoH1hwsNQ45@(i;IVFkf@2^H7RjBZbFdNa{qW#Bu(A zeyNWA^5^e2p8WT8@|RbS{@>~#do1Fp^sN4H&7M`)Epf`Rkr7dz&Iq5u^?ZG&J8A$w zA5Z%XzLw>FLw-sja}gTyzQ+NE&e7lKKK6q=BJ*h}HS~U*q}4}7#E8JNxJ)fYVh5Ka zMC}E9?x!o&jrcnh?8CaAAo$vR4>4mn?!x8tJLJJoz1ajBZDB(7dx+L^y#Yl=Tg8RN zPOq*Idi5RLO<)8KE+{&EpJWMj1cRBO+CLu6E z-l*3}2l43Qa>KZY!7I;DeM0)2^vvocr|F_bV(YX|5K+aWwIldfuq>t#v!j9b!)91# zZH$0O)y)U|>sVr#t_0VZ2Z-M!Y?FL>^HV)aEs1sqPe z!uZEVTuGKI2s9dXoIF6pQu&U2O*}cYjT5nB;p|kbt zS~*3$a3i)pr*eFqESv1^PhBRUBk2Z^xrD(JGvOQGJRe zjbkJykiJ@iX1tg9c`G&vr@)B%w2t-2MOA(FC~iq$H6a(rebeBi_+NZoSR%DnO+&&$ z`^VVbO%ozqKCYUW6fhz`>noTvJVq<7?l!R8BAi*Xog+?Ns!=oOe9ma zP*^Mt6j^kmP-S@`L1GltSC+tw|CdO>0R zdx;BFcr^w@>ML-7VFL8%HaA_=t??mZ$pTYf=3UR%MSBFg-o8{TWv$9>FYr1c867l00k$#q8=u$QYePZwwa?iSskpU3PoJ}Qq=tm+J%N?F*r@n z)O0M#+Wf5M#IDqd*2J0RGz86Wqp)BJ4@ydKv0TyGErV>nH8vPp^T>{5sk#_lQ;14* z*)dca80!9AOWh0j`z^-szi%m~upT>au>bRWbE+HGzwa}@_XGQ{-=9}Yw{ckL4hc74 zx8>*(t9w?}GH09ebe;_NW;@ltEo@M&G-;D8NV ztqu%7c(f!aBTZ5aWpfMAoT)=248ga`S z(41ex+5P!wuqm)DrH-;5|_!nuV5c)8T*;-#~X@T#8Z|_Ek-RPA3W|izO{0{ znR9LVWZJYWL`5yLrB%^HFdor%Oth*NepAe<(lBfpyVh$WEX0f^bJ0u|hQU1M*Gr;j zMt2A6sFK5F-1`N9LC<*~VMsda1k^(X?fx7BjA6`|+-7(P3)2 z+^aY(xUlQ5RkdnHuvwO$>J4+^)GP`Bk*J{sO`4*MFmf<<}Uue1#8mTYR>Xj!o8nZq6yCz~x&zcr(l z+cKa-cC~ZGXX;uM`Nm9I-t%UOvmh(Q+QZ>_j}BCN<2NI|DfgG(L#{+Sbf&^CKEg_4H1nfLxT|=#i{cBzy80c)#1*ax8L6T$K92C z{PVkeEAsR1+k5x=f4=*my4Ky;>~uHi@w;gsFSu{M>g>*^!;U;~|1m@H(%EfHz;E&2ZP(&Z%x^Bn<^@VYD}_p5z6a6FnkB z($m1eByaNAth}cK{(L;CA?N+V-tQe^S#>q5-QI+Us+?I~uLFITC4*NCrtn~|4a$T8 z5slj&8n7`FWc_P1- zEv1G^oy(DW2;Wl$?vp!9XH#77I#d5Vihjs zn4xmqBV4}HNHbosjJAGo)i_F<%o)l$B@e_{SZHsWp0!tiP3^5i(Ow<{RNxHD+~!Uv z&3xzX0))FOGD>yu4iMOB-r0c*`)}lOF^mo1@t$CXRVDC^*H^`{rKUuS1xSWhr*?zb zyb1B{1~5i$e>y_FHnyc<8C=A+UusJTQNK7TWlRRt)-j$wJdq@fDy;-=)X>GDPEAH~ zlQ+8_KI@S9p3$q<^o*A*OswYcki_)c-r<=OnfoD^O2*P{eI4~VgfW@rEJQR9Nv!3D zK@#dwf2)fplHgq~>rVz=1M3;c<5hta&rrODvAMv0o`(-$c$5}Q#j3kKr2~~%H6FNz zAn!p(pi$=BGIqjX&=w128w~-WQL=;MH2u z^ZLv6%H6gI_$_lT{ITl$7kmb0wW!T@Ei|Wvf zGv&d?`UM_UnRCo;-FyU%Ql$;6(m7H|`fe z-5yk~Iu<_0dw4XKzlLM>ro_k?!P?UKO-3*#`y0#F*}`MKswd0zVm$$O8T*+`kltbL zHlj%PT%@uGyuTya68g8|%mhGm;Wr)Pe}`G!*+7KXSDlq_dlRWRaQKE%%*vfX$>ZH! z^vDdxc`SR~$-wU$d2$13dz>Jc_Q6seU>4_iv;3Xr-PLU;&zS(HTc~l#Fw&eiXuhG3 zSfE-~#J-*PGuqt!h9FuPRtjGN3zvYw`(jtV)y+5D+GVs~lY2t3mxqUF#?q<6 zm=ahzl;<;xwAxf>S(1Vx(|8avkZ&}REJm3!`#72BuBgq}eoVK)HER@CxrP+LJRWLb zUVbADmdFvwL_leJ#wHHOqiw90Ggv95y0M8-4`BTjap5Z->s&+xk}whlJ_G2q7-bV1SUPi3Or{F8opcB<83u=k& z#Ri2sM;bgEQW^|&S()KoJQj%;r>FBx%-3OeqdycG$G}Y*iW!v0IzxNd3t^sSa2|II zM>vH3GzarsWAN7ANGwztfrx=Q+long_YohPM68Us*MoEfaeA-Dw!E&a5&EocSUuvnJprbXhy(n~UG! z_v8}G0?ROm!n0rJgutf#30agfjH}D3R)A2eiZQ0V4igwFvD{pU7`*UD3@bs#Nled#8*_|q81!k^ zi?NFB{a~~?-0StL(=@jgHXH0t@a6$e$|R{n%NW?Ndymd8%r(^+mvgS>X_mFfy0@`` z31Pbe?3?`Z#XImC685Dgt-?-zSxnvK2Ab9lZdK&T5D*~dQadt>D_t>7+mjJVB6`+Y z;U{o;Xe$K;^(i)dvJcB)+HUE^94HbGmoa?dY}Ml7qUdae z0-Y_qlMpsCqM?^DWG*`rOu^abM6HrBDI{tb|J>`teUY{B1`J7VN7>ten$}tlYb%C< z?tmfcoy=~V05YMqCS?qngfbOyA%`Z|d}nW$jKiv+^9+ZnPhbO9N2g9FWqA?cJc8WH zsk%v^mX;*r%}QcBVoE6ph6XxhjI%9cC`0B48|n;ZnoDLtXMLKFP`bPnp*Z%Of&iss z6*>W_*f!pdlUO)e;>~st!s3MXCZUAp)H}|G9XT+6R#1IiI9mMD84f`G1?6Q!StyckKchDn5;=4@f0*>s_7=;C{ zpddCJdbRhib2m=55_qKV&sXZ8qnkrL4MDPI1Z~`zZJyRPpCgbRf zh{xjDpb<%jqcI~7Q}cKTIVgTGJtjDb^<9pO zSxit_f}u-ekyvP5f?A*%Msk8^Ob~-VE~-MX*(nFVEX8t=)0L)3JWe6g4%Jem6DQGX zAq!R&bE?1-ONgMUlp#@~b6wB+VO!=`(UQ|(HVaWV(Sbdyg8G3YY^;h}l)yWEQr=kr zzLt}rIn3A9``rz)A|2`C;S!uQp-&*t`4N*aQe<^LpQp--e3X)BGYLENk$em`217c; zleG$(2o_^vT4#nW2@JEG!;m)jW^{6^xOdvYcVQ}R$$j_E0{Ei*i1^b=|K0-lw+rCk zEr9=N0sP+#uy|I&F-jxOH zUC_LH3)p+_ZhP;2+YbJ&9sH+u@V~W#zi$WsxjHBl{0?LiYp@TyQ}h167*gm&>|xOP zAU+NC1=%Y&_-1uHBy!N&h_i;nd&F;hhb{1lh{NBIXyjsqGS@kfkzk$nsgeXC7ZKMX z!gG33he+>Nj<_VLMvs*p$q2DZ^d7+h5@!4G`{#+Z?Ga4l1Qm2ec_#iDmn6e;7;va6 zxaSI6I9=GV%m%@oDx6tqr6_EOe&1^w8DrW(Hdo=ue;yhjd5(1sT%=z}1^OU!qY6o36&P*Le4YQ`C^rQCy?VQ2<1|7HX5$BEE>JabvSr<}o zbDusKPIkK0A*me(jaKUy_^e0<9baUQf^CAw7n`Q&r})80ml|aTVuP*G7L*>RPRC^vrp@J&Ij)+t@lUIm+ zOR2<57Y$6hkR=g8*7-sYk1uBW#=U!ZYJpXn*Wd-7qc9rSvyRC6fmn2#JHlMaF@U4r zd^*@9F=}1sT%gSEhrOtQd;LB}G4}3ISm0+j4`=z%SQny2fKDin8pmNXpo8;Cs z8}H%$JWz%)u#AP6CJEMuMOuu7y3;Gzo(^ublK)W;rgz~ha=#uBJ9ut$O>ujyztNq+ z$FYmeFn&Pawgw_B;x_z4Ci6Xtg~=01@*sW2CQY(vIbz9a4@Z@~6^N1Z0`}6>Trr@U z1x2O}6An1UTA0l7LV09&03s4GTnx9d&$fyN5ER)dMlCdLDBtj6aqOt!u%V_$CO_BZ zb*z65Wx?YL?qV8|f~Nz7f^||@Qy#Q$`Wxab7suM{pJ>BBg!yg=?jfWdY_;R90anV0 z&B?RD_NcQ*78EPQ`Ry=EKZ%gNAtJW0UcWINcYE-XnRlibTLa{Ajd~sNuoIYUjL8Kg z4gm)y?;i|g7G&ID2ScS_)1B;VrSe1LdCGIvH{Ic@`3{_2ws#ysLxf4j7!xO40Kyb( zrMPwkFs4-i{{bGikQKe&&!`|Ib+6YUMxxVt|G>t^JOz*GreI>8s(@REkS4b-$oy9##q@0*eXwF)d3vItxY%4{1I&KxFvf` zf6V54y#Wq?CHXDp946j$0Po6ZI#EBLdnpnoskaY@?YbI{G}DRhXd9%&TJ`Ps)qCt! zc#i%8kuJ6m`ws|ZeT-ePq`vG^*y7ieglaP4`uH(oYJ!-4q0#7wZ)i2z_o2AlT_p#s!d(Uikn?yaqvEf#HMv-HB2s1W`Ri2%|2d ze%`<@tc-N3gFQcarLpCHqrZcw2~eB15d4=P0Y4%h9PCSTtUFs}4>cCZ zA3$N*gLgV45YExDu;~g04=ofioS~4}yU`{(XFexx;qL$oZU0AV<9l7izClO02so&; z`{HU|_9>(kQ5Oh5PbVPm$g^pZ^d=|LMgi}d69wHfpd?NljOvLmNTXoH8CD&|T$}e1 zVxl{uFb%YXab<}FV5jVQXPqXTAhr)MbkeY6P{9kKV;|k>P(hQqx)QzCS1ue*I}K%8Zk**g}v3OpsotM z&8kjEY?c)eA}3~fK(kKFkM}#j%{=iVb@+`Kqui#1|(XK-!vMe zj}BuB>l`|WpHoQ83f1Nx*shG<%>DweciBEdj4R|3^dYRg@G3d3DH``5Re-@Cwr66i z{OU{~gds;@6*;iMk9(n_{2yj8`*pWEC~5cX$G2z%W4#!oS7sP#{MDJ@_h}O{98CQO zjM(aIlC;LhMW}-cBe-@USUDR+FNQSpVEbuni-ggI0N5JL*T)bcw93z_Dh9z zOF_T)l7yqH2u&NNA1flK*%KPHF>wL|>kk~Z+|_Q@eccz!WUR#O)nI}yVq zxR(Q>oLA?AEbH*I^*Tu2XWun&56ZzSb?^kADS`#9g7}5CfY!|SHehkBj*4UYOLDhG zmDqQlKVI~qc4K}h0)_w%@6Jazc3IkGRQ&;`Y3N;<->2pO172JNj%;-ACEmoAg;FL=jOjJTH&R}B-uFD7RQVq6wkwR-FX|{t=QeE_4SkBCyn5xfY7_DO+n#v%;7eH+Hl3%PJbLlKQa`V=bhOLkO#$h9UJe5D8x zNesp%xj>1sfYEuf;GY0s4J+=ezEtpR__SP|gK3 z_;{sK_48#gMaq6!M;(l?o?wrc(kzr-Lllx9)JdkKK5Rh{5=R7srTIbZR^E_~emR`z zfQfQ}MGvH^l|~S&Z9F%iYhjzGZ##7E{Ej?#t2@PV;7fxMNf&Cu0U2wZv@WDI1E%3o z8#vY|>>}{5gv<4Ed2srJ{a`K6mr2cBIqZN9JqTAgLjm9B$g%n@)%vbEm)shni2e1N z{joV)scu&j^jI-IA~sXGNp-i!v%1jXE*_Bknf~ zad}+C3_Ku&O(k~Z)&4A{uQ$(1wayx-n8iwGysM*Tbv}Tt&>W08DF0XN2dQZc`4*}> z|9IG)K6EzwYa#W=KCRKO`yP7LLHA%9($G$_*2kKV5 zvcukel>cGeyqpiKkMRND7}8ky&_lhHks1@O(VSp1I38;A$g9=^&F7cC})I$ zPny_cIP}wb2C)NU;SeW6xk2p-j9(%)Z`r53$;0OHVEfWuKgc-Hz$I^pw2G#(&PSn2 zsonfRQWISjKOT>WC>{fHX=)`n>5^Cw`UI9up3pCY*#MLJKgs zCeOpunHThv-wj>or{tIl7&@4&!Hh$D^z-iHhj1NQTBbO^z_3nHH8gP!^F$X{hSc73 ziV4tEw&roY{NBtZ$Uf|_CL-+4QIwT0{S&nV-hrEIV0~FHO|LjL1)Q9c9O|2VyU~grnTeSCBf+ z`9XKX4EX`wC*Pm|OdfaV_~(ysBkxb6>Fy$@!Y3N1qZ&|zWj4BnanPf9*G%BY@nkQ2z04?p%`ZNRd_#;sKmbKaZd zn8CQ>$L&krG(R6c`KZW@oY&H1ViPP-=s5O7F(~HLx_Bx|wPcvRkGxm}j`Ba!4Po}W z$RAO9JW(?+i;<8VSM){dytSgtVNWM*3~RlTInxnjKbEmeDYTtdS9X{dz=EIL`ea=+y{5Vx0j_ z-1^m5ZM64BGl|y)J!f%S_a^YWfU}G+u(kgbb#eb0BD1f(SyVb%0GMcNv)<4`VU%eI z-Ab82ehYL*1@@8wRt@o3&IV5jr=!=EbN&}`^$ys#i;LFlVt$A4$%0%OD53hO9Z&Xw zUoL?Znzn!qvX{}eWy3vZgU9uaYwiu|+C{w)aG=9;#FMJIeGb<+*4(~`yttbq?!s=) zQ9UP?sSI{jbmzQk9uiW5HL!U|Fy5je5s?Cav$^KF*&|!|3wlEag>iTR1N;c8nn#KZ z^l=Fhn^fL&1j7#tCP!}~2TnzbS~zI(7gkbfe)|DZR*F)F%B903k_ zzEKZCyRzRe$85uZUTZ09bIO%u=f?QR-z? zRf2SM3WZfOlRenJ*62kvY!U$*Z12JNR59P^Sl7l1GZzT}2J_J&$}oj5qEsE@+v)r0 zt`Nl(wyyZ$cP;Nx#2Bgu9p*mi?hc0U2seHSYq;Im&E)B!?Gb=RGB#M8BnqmQq}ypU zm~eQLsQC2Tl?k=qFeEjM0ZX>>z#o?+Xn)uoR=GTfiqjunH9zhTN%rxnOeP9f_p z*#p+oecz=5c$M~2v}xjuSq3YCk_FLHux$;S>gjkkqcBI+?ak@C2~Klhs>DO=6P&r= zZZeep4f4H!Y^Q)}z49UaWVaXC@8(ipki7!pKVSaF> zV6p;}g}gRM9Sf^JAl6Ft9=l~73Le^LdCxH6eTyDGU~1yo5`8R1w*IG(AeS@xJxKwD zck=5ve(|db@_7WI;9!2|yNBoF?+0YCp@LnGW4`%F9+1#9)RN)6`(lhmRt#=vi6xkYk5kNzl}el91aCDi zKTklJT1c7+UG%4>#8Zu%DPTtYkgzavkcyf6wW4f@zfJT45_Ta900oYs#a~wRCGjm@ zUG@1Q`mFWM=-SDxM%37%4;pbK215%G)?&Dz>y1RHvDK%oV8@F^h=B>8G*aZ4Mi|;0 z!nta0otPx6j~fZ;InySKRK~zA1se)EC3BVTyY#C9AwbY4hc51n_UN2J$UiMWxH5@aO5xg?lQJ}U&fr=tl z0FwdDq&lzRVGUP;$~wM)8XNFsa~B1qK(VDA)>NBzjlFHdJw=edF{zcp(muAaSi=z# zz6hBk<)L`Eu^YeRG6fUKctf7)zG>tJ13E+Of~Fl>?%48=O|hV@N?73&!WX&D~6 ztz2E}F|6=B^@V>}7Wr!{i7OnYI485?g|1;xECPNMOjxr+D*Ns4@>L4NFX(U5${T?2 zZ^C^qUP*kOx)XrQqd>%CQ88mff-0v#EYHzLAjym4I$s%If2sz>CLUB5d=^Soo0fGg zmn4!7N-~TT*l=iN8c@VZOO})Z3jAdjQ6Ush7; z8!^quV_ZN`&DV6O&EY4iOPVi9q$0-vvf38;;&`- zIHC`<)X)Q(kJ4!!4GR@tXk~p0-VD@iXtdoRXp2y+O}M^lqc5T`T^oH)X^X?z8sUK4 za?>>mnWKheE%cd5HL_8grE3J6pzPJa;jlfZIwt6I)TE9!2y&!ZADaPk%%~bMB=8Lm zSqklp+H9en#N%Qnq|2iNg))_?761O#O)BwEMDYsO*7)o{$_TJIyHVi*#d za8}tI4WzhpsQT2I1(q?KS0395u+mCWx0j7LF0qa|=UXq2Hs;}F3Apvzs=3H+iH`=2JX#>}dN7D53i9ByHy zvS0VA)0*bop^%@^jEg7r`xkSKdJk^XloPkW9?<>QV9GmANvr8+yxew(pd1wCApIhv zGAFT-^e`oft&)GP!3V2f$xk-bGwtX;c!2N`9D^vld4Vef@{5Ks#yryKml#UPp45e5 z*iuojCY`Y)s)DASwKT4bCLXiIHL_C#6xf%hmM@^JQy-kN4D`iblc9K+X_YD?^`{Rg zT)G&=&QlmuV$n0)@sD14A6Rr#N)Ds^DHdeC{08R8gL@nv1FYDS00GqjxDEH8j;h1* z|0jsJgY=VryoVoiKoGZV9aHaa{J9c;;)O3m__jJ@Kb>(sq^-h_Rh+7-l&}pRpyYi*2hWF`~?<)P^NG) zl=<_^r&atw7{pKjyi57sSapO7=ty8xZmno-2VugSVR(ZB!5{j3_$dy~a$UB%m?sAl zyN|ztnj*4Do)V(vof5~I$8@7~On<9CK!T#aqux`<$yM^#cbah+J|Fi?umJk_iC&4Iv-^D>?(~U{S?670cJ^w%jaaM>QCi?daqoA8dv;T+;i8r1;}{!~lL& zdh~fnAaD&hYrn{dZTvWAiHUz+K;=|*1iqZ0N}`Cs>OukZ7=ufz)$chvG6G6DAiAon z38jqX#|j z85aZ8)LLnyu$_J5(wJ)VnLP#ip!w7%EduehphFAte zXLC_8F>Bb-2R`z4$DW&_P_=Mhav8|1vAeg64Ft{utM?GQW>_7dznCoN9u#< zOMz90FByT$r#u34;e4JVhOmTj)Chz$7{fj9x7by%6hd@{*kQ*(XfWFeV$h;ORVX2g z57j|zo(i3YD=!Z<4#GO_p-oi#d7mGG!uX(jYVXtE@2Vs8@0oVoPLKzNgf8W88_ z!$B82yb?sD+l2_S>Bw0w*3%`!IR?a?DoelWY?jJ2&SZ&y>EfzZmL^1{G}45!noFBf zfMhw(gb0$O|e> zFrV}h=M4w!(3iH~Vcg~*@_?cVde%c;KoXO`K|-95v>`(sg|&AGn7I1{DO$QBKy@T3FyuZ`&H=4lW>%jJyc1_iL+jN8DTJh=z<_bHqTo&jyj_lQ@#1pP__j^>F z?|f`yl+fKb+{+E1llk;~AMP%&TOH$nwvZo}FaT;aLalLybRu)|@b(@g3Sa9zj6f{d z%aiZe5&Ef?yz}&^(k8a}9I%qc435eXVvmw>x3ym#lUVt>j_a2O)jObG4Mz|{24RwD zZ&IC(zfD=b6qB;;%h?nn)jLmTf#kT#CspAp?g>hE+m*BQ{nKa_^Byxo)N|C96ZPvO z`qCo;5esyJ%Zhwd_5~?Xvfyiqqj5Zi1f@@0;4Uzwa4rzcJs-wrNZGazldtUAr4uoT zt~X-PiFVT#L~ z)0cgim>^D0MGZ~2k0)aazj;+%(bLc;60~PMo|OJib$ADX=cbrMxKRcf#MW2;!r}!a zLe_A^O`m=g>BBBZAemN#WFOucB}tEqZ*|(^V?x7pK&TwLL@yF|=;9}=uUBF^uC^Lb z!f0JB!ZhRM6v%6>g5Kk;#|ioitA(i~Xwi6NHx~KBAcqLTJMdHdi|n)sj15W02o`Ke zm*@-gq;BCk!Vs2Y)nWck50h1A=qE+R>^-zsd#nG2fS5-ITkGBJAIEd@LqEhH^y>gj z5s>56artkf;eGZds7~>}2jpuoe@T)C{H0y3OL@S-MHSPVK@Kw}yg>hk>QN^A{5z^a zKh-;4(s_$~gwyFK0uF}X_uOw7dPDj{i|~lSX1i=MUz;Ko5+7+SUno~GO`{dhs$(JT zul;w96dT#u0A8I7C^2!Rn0l|6ir6Uy3f~n||5Qx&g%~vje6rj#*+9S;OYRPsngwX z7)X#g2vQD7nZmGp;h2ZAK{yf~CAy3LHd%$OZTKznlxWB^cH#JDRj+kdm+G)*ytj5# zSbIV9j0#W1_Yi|(jA2REWLZqXMZ~0l{l$!@tK>yqoeY}lUAb6!$|cPCiXkef$}DMz zrqPPsp0m%NgiT2WzOpklMj@&08oUd0WyF3XkXZ)?BZ`~>gxNE?S|KLxlY`lFT|Xt^ z0KF)V1A!Cd!{N?Aj??!O*rilspwGBlHo@~@n(TzSt$8O2<0(4bvK+GnW?=YI=>_EH zaNXyV;-iFV*_h5t4!tWiI!n;Co$jRX*3c`3L_O8Okhcu6S?59;cduHOPp7G5RF0)F zqS%u&Jlbn=oh>#4*BP7U5aiA!NFW8SQ>L+9qSDhe9!sgc&P=%Zf}6sIzXcmlr`(j@uhyoU{lX={|mdxq+E9T^%0$53(ZtOb&IKWu`%B;J_E zKRTJW5GmECb&?5kK;$NhA_-$K!l}DciNpWc+eNTU>W-uGQ@Y{kE4T>YDOJ8ebX-2L zd#9)o)gPcXR44Jrc0w#qj+rt+1G74WFX$dPs5{QC%RwJL!k;2$&hl>#UcgRSY-Tyg ziBLhWkO?T-@njsSDeu5g40MO(|LT0JIxRo_Dc1!}+M_!RJdYqnP&rhI9J!u%M-avc zKP;b!bg>Bqt2&o_n%;0yQ-eVsm1l3TO^v9)mA{!KzJU7?0xrDevj;@vM`@P=ipuPM zPaAcy4v`TZshXHKw$KGQ_HX(m&l@<05o*{!ZB@5h@z}Q?SSSN_J60uThESb~#0!e(WMqL1MLE?G?RCkZ{Vjq!X1#Njnr>axO1OX%Q7fruW zqb^XMIe^!5|AqFm*t_9v02$tMI4nRGX1;~|2j{;dh{_v*6dAiJ9$y6YiT$m2jPBEwn~0T4CS z`5Gk}#FbSwBJ+qVr1Ll`5Jy*6r<6Ep&U1DzIiV@Kq=(|=B-R#}u&|Bc@31@gjm==s zV0Ir?XOw{0u%6KISm1`FJ@pE=$tpT|F}>j_bX~sI_ui12`abj%;XAkI995r@d>l_S>wq8$rAS{Z{5G{du6?Tjn-iAQx zsE>GO^bZ?h`ls^uDE&4S^#FaK^lS3pwpLHWE{9){`bwZU{B~P3_UF9IZqfj_O-LIy z4iJXRVz2Cr_DZKt`?%Iy`m{QceBRBzv1Lr)_p)zn#uKY?8UZ|5d3rK6w3+Xiw7zFU#C?*Puc_dzq58~4)ROi|JDYX4(qIII@ zXLJ31ntnfryNc}QDSX=@P9py^G!Bk<^gNw^q3j~3niDF~)lq~2Q}o+=MnjW^QxPf= zN3YhPy2~ShQO~NtXEd3ZyDxlw6e<&{5iC;VFcmBg@AC6CIas_$-UaAJ{0+uMOvm`i zFE0N9?6@Os7z3=RlRN!aYdfXMbHIt+q} zf5rfGbb!4nrc(8pru8{6)pH7jO&*~$m;nAdnE$m4OLOnR2JV-H+;*w_B?P{e4Zjk3 zrsR^6V{6g_7>DPe#78Wr6@nUK1IX{T9JQn|M68jr^GxCsw+r5QRFvh1z{7zvZ!D}m z(>|iB!IzZm9}$hx810x6!gdh@F?``hB+i8tMotn(>9wd1>PK8Xu-ly>n0R#xvjBV9 zs8m$PBt>sje@L^0Jp0_-c!;N;Xg)$jnd1B^^~*8 z898I-2-pA&#yIZ_v4d_f}$IfL--#IDh~;VU(0hwquBcBeGS!Uiv4`fOAkVN_l>mwpr zAt*DXKh^V*_|34suV*A-9Os!D_qlJ(H(3P_>?fYl9<$bquq_XM1EUZ$I!>_G97H_M zp&dNQs;3XMaEC<-jy(j}+k(%B8*iM-b>`*3aZ4btoy5b5Iw_2#+XQXBH*vF$5I7#Q zyl=JgEueAg14@I}XZ<4d4S;qsfP2ii!ocuyI*FqgdAur zL|Lig;+<1LTqHy~xVsQz#jSNp1DDpYxrgueCeG`~#kSXo6QfGON)WmsrK8fD+|+|U zZm|}$C^1>onWo^G`pLP8t3}|};f~A3wkr$!5|^1MGg5@GuEa$rj^hSYU4o**0z3=Q zVXl5vLdBqk(!wT&<3dY}nNGkf6{XQRV%w6U3>rwph9yPS@U*Bn4bUn>5?#=(V_sIIUmD-?@wDA2uXC!`Y)1|vNyoVR#RA;7hkk=HCnm{E8Gn9hU|KS1@> zDC3%u_%-e+80DrhVaqPX7F5y8;)skGahp?whP&u-UdFtzME4~aT@@uDCF0l#molRE z%W1Mu#-)oBHI^O3Cf_lVExxrsc4Z50u4xmhRw|0}n20Th+Y`C;4T&`C!Y)KJFI9gFeAFyGN*)vQ<%)>WvsPFr%+NIfdoL6%M@s$DMTl=P6>>SYMpgBbd-x`xT; zkjCNd(BjCL?3N1`pA<+c_?UiEqRV|F6Ry^!!BWHdwfo}~GJ`?f$+-IRZZ2w~uPL4- zpJ=?T{y-;hC-H}#cHkvgwN@mMiS{W6BKei=7lbATA+>}2#Jbptpr+#pr5elv(v2seB-U zzvlIEa2JP3;Q$d;C820YqoQRZz4L=ZA;!CsYeRA?F@ZOh*vMv9`pYp@yHq zXMWZB5YnWI@8Q<~hSTVmTOWa(8fDBoTMdEVS0&sHe)Hze7>*Ae!{f zn@XFP9N}U>5iJh5p$(wl>Sc`K$58b-#Z=*Muwk40v5v{79LUlrA!MBA;&Hz#`hn}> zdH{z(jsqwlSp9L2dO&38j)j51ir4*Lclvtp`v8Z<6R>eU#XF^R&PQ_%M@%4*Ck5f~ zc^woNVu(B(|CpWTlO<58A3s|HPr7m$iexM(R8r-6URR9bT2o~rUUvXpSA;uq#&^3B zj5pArD({RDmmT^`q@EI?T^SrG1?`NWvELnb!hFDggVXrIbZDYD1BWrpdo12`@Muzj z0Rpl1@NOykq59OJP~3g7@;YQQ8~d`bT#zpk)M^-&P%@pc2|uMSVlXC$f?~B~GzqF& ztfki^i5Fm317F>9uDXoJM%eFss=S`0gHcQl?EUE|YTNHElMVN~&{f#}Xr`+!(;KXk z!Z2;d6#=qC3f2q?Ily}f40;F#>gSC*jLsErIbc^p4kONi++}%8F&wZZ_^60u6h)J3 zLfS+H;m)c^D`iTG#CK6(WR;lbcBb%EYo44-m+IKM4Z0u@JTL>VSp?SNpw5V@CGvzG zo{@B2&nV!QauuMBZPW_p@90?^$)(kmsY&E?M$%7c4tfftoxxzet_Q^nuVRsOJR7QL z8~o01SZ}!dkRu|-G!3zs;92;^-*A9rdFg%&zpi6OQ9gY*pTcd*oruXKGgS^zLlDcG zW}XIfb9JMcDSIdpT7+yx$#a518O_o=^0fv0Al?V&JscA3JPT@L2Rgxo!Bh_iTlU+ zUw|8Lm}MV?N{9Rg7v2>JB&@lX5|EbJn1e~#c*5kfcE=uID7X50V!shFU^GPc3N)WA~Ea*v|IEHPWsU%CV##rTNq#l6S8(KBd6^byk z;E1LYQCJalR~<#QQ}G$l^ioIKa=CI$1BI0qtNAy}VDamEVq1dYHDRcd)q{B#6-VTK zsFUJpx0ZsmVCNFZUZ1mF!yIi%=s{3^(kYVSk3En5KMB8$Jw`?Rdqb5C> zs0KqU)8r=nc7UJ_DMNV|oOilxjSCYo>vX|mO8|D7*+dgy+)PbZ*dB2TH>9gq^!LnXDx;l#gy{Qfj8GKztK`qp!mY3#%DBMlh)Lev; zO>4t+#4uQtX%4Ra%XU>!MM6oubL1Vm<7xGERusAWw!&2n5oZuz1Pd$FeY<39$_(<@2Eh7}k~00-f%sg?MIex!03Md_>5WHL z+g0zxq0f+-APY48mlFqVAHA`iY}9m@#!hw4g2Gy>nr|3}0}urKVLjW3dy|D$m&iLz zJ_S%=Ng&&FIHMex>GI}WaJ9B$PN|s+a3ad{S5mdFLMr#V4s|xi@R^ubeI%duoI^?U zeH~N|?8=lWZM)U@n2FRSM5AT*2^C*-I>QtY84h+)dRLePv|1`ePnXDecUZpk-)_RY z8CHO|s5%*e)U&VD5hAvla;OW9=sV?*loRshcca>>PzqluxM9j`1MX_2m&joYs>m7` z(_u73ODR@lwo{O0F2R5)3sLGM@;3UBJ+jPUfnTbysynJak3{H9a>!UsOG%`GC{qc7 zZTuY1#OztdO2@totpqa{C@D~b(Za-NgUK@u>@&eDks4*aOh|CR95pgCn+kQ{dG2=P z2>}N3_%%5u8cKphHXB`%3iP8zr%*vUv{}?E5EQU!+wdv$N`fG~kfkxHWhQUenol(fM~iNuqL!XqDI&~3?}vQy#@M4`SAA>S3g?1;GO=)nx6vpCOBfHF^**M zwZIvde#_b=0|9scBz%frr$yYec7)SkT9k)9oQ!DXDT)v%bwMZw2>4{w$-*z!dV*zA zb)PI1JtvRU9Oa5hcN%5sTiEbJctDx=6f3aE{TeuBehr-Rz6MTNFPdpS#U!4r@X-YJ z2gN)Yjn}w* zh*)dGRmEKxR6^t?$cV|nN!5i-4kL=d8k@2f3Cnc*?d4Klha&)jvGn5ZFlxi;S`Cr2Hw@i1%ouri6IjuJW zs)xjLH!3qRk7#W%Reo5j9KI%3b*3O~jd(n2t|~^6zCdbS)a9g5oIv*V{o^ey77|T+Y32@nkQ~;LYm@!yL=7-AF*MnWV zxK($=lrtL%kB5jn7aYv_byE=6SaI_uPZFAb$&O^!ITa+-ioQ~`3f2>`0>{gY;Dyp_ zTV{$ih0fAHaWs3Y4APv6vBcD-2{pzu&0OU`Gf43|BwPP8WzNVw+o1YTrX<^NtcEB*R845wh>@jA zyr@vV!(=OjDwct=Y6M|RdveF)vn`@3qDmerEmf^+C3}~ec5oN2x-5=rdrGfV9p=7b z6clgK@mZqBkBY$)alb@`RI4Z=DJR}}QmwMAN;#2Mt&RE09_cAK_?{ad7&|p_FCwZ1 zDEC8U0=F4?ioYuqB_YuXOej$<3CB~)U8O~hM6B?om{2S2c~584sW~HBCh9C0a-V{y zA~KhHI7iQ>)#aBOXqNfqnun!lW_80!8#&J7>Zh6NSiwqti&ix>GKV8hv4Lzny3l5C z$h0*#u*sFCyc!KL9o8;$jAD@g(*%>xZ)1_lTzkIdS$Ovc>9W0sOK zYw2#Orrf%WzL$Y93s(o#{Cup@M->@4q7G^mt zi-kW3m3Y1gIioVRKWA3nI^;`mpT{_D$0iwTf7lKrT^O@FmRXR)ySwghuj8q%qu`(U0_x9M-{d6L> z?xEw0{ai}XOlx(V#ObYid{vgFuU;F`19N^%l~c<@v0*@VOw~k!$DT`Jo_9lE8gnw% zjGL-q?0q}t_716FRA*BS_|4=szxC>!7I%NHQmLBlom0igxfi?2Fn9B+5xOny=}bGO zYSX!Okii+!nDw+RXf4UPB+LxJE&cM&_Ucvdz)#Wg?TOuwlnNu)dxR8^2LlvCPD3+fY8RY)ZdRguc$t{Qa0tg&w;L321FLq7XLvjzpt zDHgL0aiS<&S1~+Ly2Z6K9QE@1X60PjXYEz_c6_rZ@Kr5l=8T zPUtZ(J79Y;$gCgzF|=lo%3|mjwC0k^1l5eH6AN?rhsBf0Xj`yG%hePsU;Hnox@qoL zV_(YDeRDgm^)6;rW$Gg=CvYKAKG(<*uBw11nC7bPA3+PR159uYRkuK>I?Zwb^V8*& zjH){qCC=3l*VW&V0cjwa)6k)Ty0gI}GF7P$%#6 zNOs9xGO|UuvmhcRmStm@9n1p(|jLk7B62e@E?uZ>47>$pR>*>@zc^%wF^0BYx z_{vJCmHDX^q#(a+GYGu`?4RWaA)%#Rd}br03TQQEEPh~AgdgbCjK!Bd$M6#%EwM2P zozYMW{NhrSs%iM7u>Qlkc)g*>?uVk<4ew2Nz^M`s@l91xXUQlIg7F{); zR?+nYTyTSL)Zi7mdpviV;81(71x^})oZOj!{IGRUI{K{<<1HPh;RlOM~SH^sI%Qw zqV0>a^lH7=vVjD|PIcT|eD-*J^##XEQAq~mn8?ZD-Y(vl;3`7Cg3nZKqV#*FOqJG1 zpV)kJd@cw(S+Qj0en%^XTdK`8p$_=^kt z4X^QFCGUR5XT}h)n&+1v@>zx&HAypWpt{Jtl{sevPtinTVGvDTODw?fuETC-b#s&) zT{>Z`I(>{UU3$#RK7EIer;5oOa=RD(_S^t9nGhaW5=B^ zcBFj0qL*V-!FhYhx1;QSbf}XU9FOD6!_nbWSI~LQR6nvc^hs`|XKKiqyDIhfBq~Cv zoq9M0hnUn?5Y#i8ADpb59NOLboYY8}>>E_x$wS(zPjV{>`@6ASz2?@}ED%Mvxby*i zUeHYXf_P^oi|UlOG=}>545X>?9~lhG4J$R|@p71S;P`w9sgDDx)=MJwaqP|ZtT+W{ z7|V>11a&wzjbu0%Q|~CZ6VEz3gk1KyRASaQLy(DXd!K8G#hKP+)6K`>5JxNPsmABwX|6_~zrVQ=@9!sPo6-mQ$R*#NEhf z4e~|xQMi$4GvL~5;Q9ne7oXK2Ig#GeWy%X*CQNZY<$$-qM~HEF9pQ{cWUPe7Ey`^$ zse0--swpCbS_vEKIKvw1ER(G?cj^{|#L`6V!x5!F?Z z?}GKLY^Uy)?rK?j-E=E6R^ojvb7|kLk*C*fzxrjAM?N9z!+u_$`g?sU6H;Eaw&r6| z^_WwwM^Wzz1twPqmzg~9$18B=IyA={NV-M!EDb=;xOUW*a3{LviuJBE7V6DG2MLVfFk8?aG| zaQg?pvb>kik{_fUId&jFp=5nNV+1Z<4)v`l=Mf5Z^~%U)CAjOoy|d9+K2V9ov3DL% zDW1mxVq4n;moww{6kLWk-kEoR$7k^*lo~({$L#G$#Gc`~jE~2@BQfq`8q09X7WSCh zvhBv34b*UTRWstMT4nVdW8~cialb(#R5iZH+Yi*2HCv%tQ2&p*s#+#2a}{k#_7-s!Y=`k<@dGJ7ND3(L>z75EP__Iy$!zn~6K1)_bL&DYa~&tt z&isL{0w;Wt0vHHj2D>nf*+)?W}d3 zopkCJ?vCagQ8e>UrpVUoS-S$?-yznwBstqf38W9XgrGzwV}Kqm!rUY3ix@p(1)v4TCH_f?3e z{qd!^vAl=HTy3b_#_rjWlv3I@eJc}F-XZ&y@;;4FYvmflGQ5-8ki?sxsR(>Rao|@lNAcsv&_UBk-LGpp7&~6dRV%E%*YQ(0 z?PXci)x+!UGZ@av6V94qWQk_6kI(ve=-$N9j(slxFJ~XZyD2Wnk!zXpylvtQo z!n35pLiHg=;7g%OkmCWSHLRp7EUwi+6R(Fl&>sC*_kc2n_;lL2E}uHp;j^UZvAZ`M zHHS_>#n25v{VwN#T&o9dmHBW?ryy5EW`vc6sC>}Zv8wAh8hRScXcbtM$m2b?T+|ma#SQXFF5%LhHJ*r3vy0=@xaEU^pAa z4c&iKu5IuaR|@f3n10+?&k4z*T%)8egkdF%RX3?GxkIeztGYQ#-4Fj z$xIy;$7<6?Js~8{I-#<}-w7CH;0qcZ@{9)aop5+=KFFxfH~J8tCJ=qYe;2oHXW*dQO!5rhXV z)oMSIV|<>9j-79h4J+ktL{euU4^(==VmBO^xR1>pI*q`bF3gIBi)6V5U z9N(lNT&3I#i}4t|5So!KovikK`FN1~gtM04DeguMz2sOo`5Yx-EMXTBYtBl7+yOf^ z<+i3usfjV@Bi&FwYQpz(-A}C;@ptr$;EchPXiNimTm&z${%N4vMa*>!iO)DuubOImmrXPhBH)_&s9gD;-{Fxs)VE=`{*Lz17G^=hcMXWHQ50K;3qLoAimnQZ-L%wj>}&qd^HVhZ$~ zoy{fHh#fjqvhHHChoTmWCDuQPxDl^CgcnwjeJ0R~te9Th-1Le@P7b*61DRZluiQKc z^kR>;xHxFImOyxE?dvWCR7P7~hZl<8m2Np$_FneddQX)ckf2Mw(Vfr~n*t_1qJrT2 zLe)|8=!KhaJ;J?$e7!XXxj)Lk!l|~I+kydpos?%qglcnW+j5y< zYF_pUcf!GMfuFXiQZ!+AM(%j+J~jUF-M_#FODc`zAThi3!)(b+@WZsyC7d~dLq_^` z@^66#imYVQ0K_I>)axgCyxMxZOUV5Q-o2 z4?|Lj@>n;0u~j2IKazT?eBGdVKv?$rlT09t{TIG8l}mBx`UVuyd&5e-WEY+!hl& zh~_l;>{HXEJH?FKB@5y3kTlM}?uL4^6Asn12=_+A)`{0$#Fvqe*wtOtyzm-)?&zii zX(b#sa|*BLe@f~!)9d_WTOYzcCk>Z~kz^Yn@3rYBY8-J&hhCx_RYHny7s=a;@9UC` zV|R#mttdi7wT6l4FVSYr@bG_yp~8?m#4C4rLQgv^IzntqyQw2o^F3R9>%+z96DMe$#v zn`Ld?_M7BJLbY`>ezzuhRT5TinzV2IY5b;lUH*4NJn9(l^DU|zhX`?y_JAWg3%hKg zmblU2ff{TA$1?FVYeeT>q~m6BdFBaJRCp-xl8l!3gftFIF530W-5 zSyZQUC>R{5nVgHg|I7i6r;%aP?P&iCIQ)_t=WgXwwrgFS+OL2_KMp5AQI6}%K5=!yEVW-zoViM~ry9?h~ZI{SU^o^>N{J}X_ornfsL|orY$QbbD zx&c6R0zi>{n2u8#!YHC=%H^AVa}Dl0irqe;q|}~t=7G>IB|85a_g7mQ$Pn>ZmKyl0 zsjjX14R`j7yh4$#DAp&|p4~=oQ(;{X+f^mx<@UuY)fd?`(FR79`j+W%UU1XOLKW*V zB`fq>jUg?O%eNT8KQWY{=D@)Zc2YM4xq1;*mAI$x*_m%No)HD~F$b@jE&!%}@o;B$#$5z_7WAK|BJzBaMOT-N9_9mBi8B-&qjJKbH zC4%;{Ep(}j9MEpSRF`PVQM_S8(-B?&7_D*P8}=Y!{@ELM9jxe*R(O^$DAO9FrgUDy z&t_AB_Voy%lPkrMUn_WN^@UgYVU$)jY32Lnp=e>(4>y7Ooa|a~2Xqegga$8PeG;lK zCUFbOLV3?R^9yH3u>>2#th`w2WgbK03zn@dFixH|%*X&bp#PJ{_=vR59Fz4|HjIZ< zK!D7~(%41&K8JYZy$^q~p!5;2im4*x$N?d0A@OwxqTQM3Cil(UW?szP`AlKj_x{-V2VZLSHLY zDT3vJddC>eQsA#e*%czTO+jIa`6dyOM|Ffbk%srwg001vn@-3WHa6pzq6~p!#+FI? z&yPCe+Mt2x?om%0_(g$A>oLeFG3g&a*PWrjXSS50U@;THUc}1K?WEgpXMljZhq1^U z+(NLm>Czw;PtH#IwmnMr$1Z~ij7sT$t)dj6=^WVf2BCmo<*-$5hX*IYsDBTjYGFwa zyG}#FOwf>`rk3toY;?_M`|aqVS=2Gd8W|54`6IT4Nsdk6N-0$_bf7e1aWH5a&L%fg z2ix{2%Yt`v=c6H)6T0VlWP&#`Cbf@T_m4V{h;CDYqVe#5=Jpuwg?Ztoof@Jw()iBu z(r3(AS~^oi49IhRuG6$TzTZRt992H|sSE9Tk0&T#WEkw+l((+vhiojn1>S$V59Dti zigLV&KMmLKy$L91hG=T)5mA1IDY=R9dIslHPdj|7XU!b;>?3=qxl47uw|Fm*8q@#D z%Gsq5#bHai!8Alyfsh>#_$xJ{aMIj*cbS{CWMb4QO>GIZc{DhQy7y3=$Wj7-3Ln2& zW3!uOr+|sl^*MM;LjBFg2&b1>84w00u=~8V-T#JU|AL7Nk z^Mu0AeXry~BI%s>&7QI^8^<$**D$!I?~<=7JkBwCQZxVSvryOlr!Jw8SI7raImsSji!}I}SOlLFV{G zX0T#1VSS>2xZVR;_&W=TNjZga+aa!|(!}(p?z<`Q&nA3~ z@liS~U3ju}=yQ0~r1GQe!sQsJ=lu}8Tl9O+>;@>`xfLT?L+YQsO*xSiX4~N`i}FFo zQio0UDS*WB0){o+j~p97R#LC|lDo9=CW{AYX2@31cMlIIoi|~~`Zp(jmb;7pE~oP^ z>F$hjB9|MJhy@AE~ zQRA6Gh8l3LtJXvZ#RBNw`F zlA&ViGM&Si6MqO@E%3GlTWpj@0gP$GtK)~=0y9gu?2CF*z8uUw-!B=w%SQUdo46V~ zC#}u?TCC$hAvLAu(4R%&?budrQ^NH*lP-;CbS+)ti9BHh0YI2>dy|JCG3-r34W z;$@sV<+YCwJ5|0yVJ)|PQM@s_OxSl%Sf!Osmm)>E2h>sJhdyV2&N0G2U-gPke5~1& zx)$WY7S3j|`Q(57#bM*Ky;|tr>fcqjGj{ezYd(SBE&fv!hqQ2c_8hJb?K!C%R zz^AERlNnm74d+j)D$L_$E12>$i1+#&sYvLI*>gN0f#<4hM3I(AzXNxqTj>bOm|%Um z`=pa9aERvNgYpFl%X)v|G^xwh$xLMWP&jaAPLbChR+q$oU3wa&(Gwi z$0{XF$r>HB1divFPj5j<+zHzf)3Ee<{mx#5zV)+Y->^aP!lZlKrY@pJyY)%e7_1>U{D4x%{KG zrPq;%=GJwcJJr^uMCZFUl`0_^v@afj%SQ2vRJnK>1Rn5}s3BGQPD$sHh`bc3jMzbO z@1A{q0qjPlt{TFFdB$edgV|5+{8jGc7~@zrYC1;0YmFw4`(~q5nZe`GaM8te=gp~j zd4a4kC{m<1MLw(bmQDA-C-Y){!sHX^B}khrBMfe@d?_&(lb0g4bkq_bgIij#x~}ft zmkllN?j*)eQWkQdfP3Eu9m{1KG@%EVTsPn*UdV=-)h3MNzd39NJ@`SuPzJQ2 zH3)ksE^DT1Y*r7!=jkQ$`;i=og}%VJ$YeyX;by|1%|XNhONwj9Dc|eUtQ4chW9prb zMCdm_>zzLL6#!qgx%Xx#1mg9o(kI_)u_qGoB&szhj3?N*wio0<7#af2FQizHZO<9_ zTre3;w~!<$_SGuiNn7;bi6`xBs2Kf5^)Ri=N!4aej_&hIl&11j<)@mu&r>-A?3NDt zXl; z2uA$%cAU}d%6AKwIw=mE+a#BUkJ6GDb?0_Nb3YrYh}z@}OsdrBPVI5pAW2*nx%a*h z%yh#{0Q1*7mGZJSJgh^Fgr}2bjUEdKJfWa3Ph1X_h*^sc{`) zhRSNUEzgYclu3tKv?YoK8eYeGWQ}|=c{x@k-^yk9#h0YrMZjoaYqI0)!4jp5x{#3Y z7aBd+T4PvdtVG3k{L5L$%|O|5DkpHzQcju8QHy#$Rb$>IRbEJ~^qR`_2j%hBcvAJ= zHts5zl81+%8v(3~mP^I5?UGRcbA>;zA$r5F-0kWr^bUXr{p_C{J^8KxK zUe9l70eDhF`;w=G>X78M{|Z<}aDaQfOxdUCR;>`xC)WE8(#md|?5blJ^4qQr&cc6& ziB@BqrfAp3f}pCgvX)`zUbA}kJN+A5NMr3LwdUAJmTrdMUGC+XPXo$aKG!?+AvP`Q z7njl|v^dpP|4NqWYh{wnmuXr8@$h*_&2s-L-WoW<#(|vs&T_LA(w@{36xm@eQRVs@ z&<0>g`-OoxLNQhW?W*6SHnLqtC|yG;#>!%-qJ}U{@5NTPyDV=oCRGQE+d!Y1fo z{(jR`^-^p>3ZqD77Yq0J2rR_lJfqlzKk*fCSI$m*O%Q2CO%r?y;@${A{=f9)AWhiL z2Cw7og0DD#PZ)xty!y>RqWE5}*|c|nLgzfY()=pC@CgG&^S6rmVTOJ+E3I!ZIKrA z+gPl%K2)g-rH&`JN*0dTYPo+?AXw0c>}e=ed@Pn^4$m+MQ*&J5M+s#!nwt((hZv;5Bv`{Z`En8+lR>d~rYp6F_LElFE+YUCd>k2k7 zQr)Wl*}@E5>VF!4U?m>EKM+dJF4H{w`fR&K8L2l>ra0-=C&I$9*PDn>b!k14y4#k& zvYlIkPbamRs@^w8RE>P_kBITwq_O;>d$8x|ZwPgArbZb8bSgh)( z^35PIQIERr(kV8vqFES0?;Ow9hjqniOK4OEdM~IPpJuN6*{JxO6H0Vt&0VadY}-~a zIx6G$S>FPK{5IJ;YBMgS=!q&KAMiujthH`-BizV9!30V-k3_UYohBOOHg~!(HkH4` zvX<;{Gn9tUx5NC4za~Yf32tHP{?5`=-|O(l`)%6%I$fOASkO}!O(tn!ui#8Hih}GZ zT>F`1X7w1a$pKtAiup~1+%Z=cNW%BeNziKX?2dxgjMsAxDc^RkS2% zwa5G|q?t4i@Ar*NV<;aPF%iP*=lbNBg&BGbD=&P%Yiz0Ue(71mHD+jL=R4=AJtzGa z{u1*+^4$zS3XlF?FMWgGD<3ED5;2NQ=wrjN{Ej1u2=vlf`=ik0nI8Hgqvi+`hT0kX zT}vsqD?4`;1eRQrKmN=D^yS`L&1#X-%M1&#+NEdxYlW8*qKYUDGVDPZJWl#;g2sg* zcc)iYB@nPhucbl}KO*h-oPWtk*P@)Sny=1^aa~85lwts>%qsXc{Fqd2zqZ^4Jf;S) zZ7v6gSk>+k;Rd(Sc^!$Y@3(ExE>jnAsZ-i|`{G<(u*4h8xJb&5G8oh%t?03%eKh7T zM#rWl=;KFB%5zL?ylf;A(oE1EgXm@1q~i;bUFj-N&&BXZQYQGqnZ5^`jOmqEt?8ev zvRihQD%dyav!&jYDcwsPAIY0wrbObc9$g_UHR%>c8XH%?$TZ3^?PyF^Kfs3zjcX7~ zV|dFG-S5ym#VI26nUPYb`W|d!c)AG0Mj5}Kox^{~%ZTXjE|0y9lp6jsN{uF`s&j>U zIEodG4Ta=uGhv$u>i)aVXo`#tSe3zSGdaOuva1CIo3+LadugmPNsl82n+V09jjmk0 z(Ar&Wt$d-+(Z>?yiXAjH9Mhv_;H|8qO=2jhPEBcOP#X*`1Kd;2mO|Pcq$P36hsZO< z7JGer@&Qo^s=aconj?lQ<+LYOnu9Vl7mwDw16N40>=LhCc0O}~pS?|LW5#ekIsH+3 z1%op4$(VJaH#!VLb3UYBxXet6nDR~TCz4%LY5b;&n>Rqk2!X}*-_}pIq+!ZR&)k;* z9$pf0?nxlNArsx@+SoIB{kOc0_QBzyjoJAgnSQ75oq8*G2FeI7b=GzUH^DD^ z68K9)ZGsIy33WfQU@GWlYz?OHBjgHgqmEzLLF0zcB{eC`ChptvPKc@>} z5q719L~h%yfBixD&dWACwp<^2)Dsn`*GWjh{eEF^z7Z7BsEmq3llB}6P@1fD|L9&B^XlwlKHX$ z5H45?xqe>9y$B)DNVC^1TiY=wKIB!NT9EgMDG8@S<;|(Gq@wY;`S=yl1wt^05L|m8 z<20>=k}g%qV@)Zh>{-BE9#%%JJd>TId^Wn8-?TeO&ThL5eS_2ZKYoD$KQ3K@2jogo zJ|>3oQ31t$-*U9~?e=ZKr-xRkM{XoExMx-*^iU@h^5tr)jLjrzw{wMSkQEIx4C?Ub zVt{Bhqw~J%%Z_N45^iK_F=Quh*{uMKg#?n-E#J{2HeWF$GH$a;*5ww&l@ha~-_hcE2+*=Y|2|qOgB}1*3aPR9Ur>I5@jHBYdm!cD6pk z9T$JJ4ZV-U_fh{=Aoau10Ko^CcTq5)W7@w#{^$J;+S+@|$Z~?t=zq%GBLXb>6T>QP z#ScXDO<*RZS zja#TA=?5(PD%cadj@hU=J&!qk{bcmnGNrLsVn_MVU1XgDHEj2Lz@ASudb{dINwk`F z&hQTgzskJaE;vfdvc<{0u;0UKdafuEoW!FK6o=UE){KyEO@DWB3(>zJk zqkhSWJD1{qe79eumE=ByG(2uiQTFpX(VPgSs|zNEZkZLhX=5veZCO{NQ@2Ywpr=(6 zBPQIYOfN&z3gKbr(gEf?mU`%GqIYZfy0G`ZEBNG4?pfD5K|)xMI<}9fXrPnzy%HJg zZWe2KvH9)R7uliVi*E(M!C>gOfw(ra+S``H*R)1SGn@)@Mn#lYgG@j9;fL`jwNrCg zU0D~FK0jjOSOK7J$4!c2^T4b|0dCEoP@ zMe1|Y&t)|_6!kQ`<<)N~Q+KM7sspUEE2Q`2H|xpVd>$fR&e!J@HJ87lY*~X`F-1k4 zEaN&Xf>tqEHDF(8>N8ELKM=jIYim;7Xz);Ro@MV&AoTIE=qoEmcYZX9Wz$%`(` zl~&gMT56MhJh!;Yq!=0w^q_|;teekHP~25Xd}W)lGj_FK5&fxAvjpZ&o2DRaGF`ih z=PVDsU1}n}LM;!~z3l-J8F1k=kq|ozU+wLnA0GSfO_wbkN61#xHy3bEryUx%1+S_) z<~PhP?b(lN-?%jy9z|_eEPvHFp*32bylTiW%x#!nIwZP^`bpDPvnqL7>^a?X*i1a> zlk#$E-k+1as&|@uT5wu^nsW<#+<(3nR7g!>s)=r|XwPcz@c-qX?H?l~QUS{?7!lDD z(1OjQ0S^%bi~e5KI_%*+|9JlPto;1_+3ESqv&{55Yk?ioGp%2YkhZWciOFKR&Em|S z__gsv)r0ec)3ev}r)P<0%4f4@Ous)uQwdKXqOR$y>1+0@)BUx%fb3W0*Vq@+XL+?9 zeLd=u-K$o^iSVDY!g9iTB>7pUL-N(;QirBjRS!JRe;>Ts6tl9GX2!YAnQP4p_JpSc z%3sA^^ZkDdX=D{B%~__fX)Us`Ux#0XU&~$TJmf!^KWsnPJtL~^P^%T_b^x++jmnI2 z$6>qsa|d(#bBCAL1XlzKO+I!V4zrGvjxd~qhW&;^&ppor&wbA{wy%q9;a5J_y$^m5 z=+FMo@BNC}x-{Tu&k@&hpg+4y#Sc-)N4UN>8ru3 z#2_x&DE7nO7nWzWXZB~;=d}maXW<8&hX92f8@&Om0=!X9ic&l#j@*2U+Np?H@T3&` zqK#CdMVO~2)RrSR!=iRB0u?-|!p>(cWjVSB!872@O`}?!L!0BIfZz#om|nu=Hj zPfD|UOh>G6ntqjgB9(6KusABh^Rez*1y@B|9F^cbTKBzxoqt&nT7fJH&)SJmAaDk-doOpRjYRGX!5a;H%Q66=6)ai&G z&do2QJgV&QHhn5!RvC79+rCLKs|0&gRUkhs%%F}{{w?ik#3qMnqXl6F9*tEW2<#kZ zkzR`T*Q)Q!D6Tc{L(X<#zBAY&y&TWds_&L#^AUXhQEp3KE-&?*V)U-c{7LP0iD({n zjXK?ub~@2DU?Zi-egRgQh=5omaBMP;^60TkS@-dRoy#rK|KjCxnnqYez#^QJ<~l0H z>}(_EBKSsAvhgrDH+@G_^6=t0O~WjnzDS5e zYQ3E|h~FGhW363FLPRLBNmY51j4G^gC&9uE0P$LCY2AOu3(LitUMU+OQ#tKY4b|yd z83qA+6_e?da}?{W+|2m^=RQGU=|t%@Ndl=@4G9ra(90gjgH;z}VUzws_ZrN-u;lo-hCQu}HPFVTc!qrWr zq269~s{qpq@Y~TC@v8HO;}{Ctyx#dQOqwVbgk&EmrS1aVef_xFkx%?;&B%LaVp2>g5P7Lpu_e zePdXX=B8^LcCg!i*JRyP*xxI9$@M6@le-Nep3`P~?6I2_f2-+OM1m&XJ2jk1z-WLr zn`@08ARPLm#yogrto5+YnwA)4p+A;)_}j-%l^(%nis-_^24re%$?jK$hT{H{LU41g z#EGakL{Wzv@;HLJ?nEs`;e?xgUh|ZfuP%tV%IUD^A@z~Xj2uHe0mq-U2grMqHbMbu zFC-C-0asSAd*I^}^ICCAK%KhKr&B>&a}Cr}Kl8cMP9Ku6Tb;&g8{)q|gdUh%C$xrF z`p2wMgtOO8_Sx`MHV&>{HeL1R>)0Y4!{yH=_9C=ZhT7tq*xof7YgnOBQkb zE9PPTwz0p@{9a6L06WJ9r+$7cv;Ud<7G}7pK=OcELxsVo`cMN4PlI;~LY(;`YKXoo zbl-s#t^HC$e zak@6LC_xKJ$;FGt8|!mPI{BUg*yoEk5Pa`;%5!|wcA4COM$pE^4v?R(+H7ZL&${yO!6@`pIe?*8o4N0d0u2F72)=W@P^%1NuW7ZT5n=2-8>uX3XYArT}53;L!(^YS6ZEg@UO#avVR3kmC|*n)d3O z%4DG$71*n@Q)dNuI|h<3n5`y!cum9P`55-}mcHP&u6N#Y+TUaFY3J-Uf zD^Kj}sbzAEc3CvVrNxJBo!6dR9L&bFEHeC+M66u;Y3`0}`kUa%!>C^mGY3x( zja_OVFd0#E=GvbKTSk1eb3z^qnQ1MNz~ItR&HYioML+px^sO5kzNpJ(O#qJdO;XQY zF^fwLm^fMqOQ0D(#_SxKEAht7paul4LrGd{)B1*RGVt#dF%#~`H2z)S^5y=3wm_Mx z3yarwUzf$svQ1{OU$5<@hUu%?)(t%L-Fv$ZDVG*hVVse~EQ~YPd;P(X*H3W#Xl#c& zfO?~_py!KM-xT`{h6Vp%^Vt-jVqgmqeJg+9vO>s6t2b;}y@f-jAg8jRGn(p>av_V8 zT)1Z%>@R@c;c+X-Ag2{U~XQyyMSk@gbF~;q4*^W^~9Ai^$GM zyC&Q2*ddj40c$Q-;o3CSbb0boYUcS~;^sLr;%GX{y=yR)8yO1DNHTKsBAeUtr&q9S z=hUh4?nsO1mf@fT z^Y&&O0cDz@`>=KFu+{aTLY$JLcNu<|y!cJB?LZ+X@RQiQZ@k$I){~&m@4Okw&!5f4 z5;2=yf18cLk|s1b^y@^}c6EmDWzCnwQvsoz~4d8(KD$1*7qi zg)kY?KST|Ho#oCoIc&faiy);71qnAx!kv)^kfFi>(hClb1Gz3^pM1wr-iv>$BQfTr zS@S${4MKyHa+WkEPWATA#+E1tLW2lb0XZ5C8ehc|uO(uXmA@Eu+>1#$_Sna@CX?Vd zMMf_<#@l826*73&4II~ky<23)1UXzjli(~f$6dC@c}^XSwG@99!|;lqvzcq3Fi=n4 z2BLST`6U+)3qG|0o(-XE1SfG07t@i^{cUdb&&(=u4UCrI);yOEDsi5SJ$@V|_Ytq?5HKt?opl$k$ z8qT=6+3J($(=x-<|J`45m?}I!;1Rf1txDNmybv_p%t;X7i;`QK=&$x(#iu^!{M+ zBjq$PuRwKNG{H%{yx#iFC9AHTmP<4Vu}*J)s$3r9%PiAhNq_MY_pdVM&ps6z;<45P zFU}TYfmCt4!z3{yI-?WyLZnnDBXz--BKwC3VoSMViwWti^mCaOHbBWkdYuXJY1SCVUoSnZwthxr49A zbYWwL)QDBbzyV#M)h786PZIbRU$9AuKhySAR+q`P%5ydKxH6U|88~9KLK18C{1*QD zk@sb_++TQnjXimofQgUo;sXf|BM!~sy-!nh^X0 z!Z!R%=537GIl8XqLr1Kb9B~}IaWK^tBFdZqrA9aXaAllr$3lr)qYm7?YD|v;=ED|Q z5&9}3`o-f>fPZA>h`;vK;Uxt{#pU@}Xg=VsVQHM(stPcuK!Uq4(vR}Bgq(9Cp4@TD zrYl#KO8=nl;&Xe=xTDI~dJ6O}#yh!jMS6EWO%Kmp0Tn*#Y&JT|1EsN8iqNZ z)^(dIMaY>~x}3}fdi!0iiRiz%g9N;y#pK?+{eExU8^#6RMG_OthuRgi3^SS%R@Ry2ewJ*YS+2r+QI|>1O}Ck?Zu9ehjCRhW;ZLhD}hW@I9M}frMhUb51M|YpvjuAlTC_xmj zJDasMy*8f%#sgH@j{3UZo(%sn$AHna`)pJ+KftsEC%My6{9M z!}~wvS#36x=7fl)DJt!h#@?=S@vsF&htJ9wyyPs6BUxAJ4nDg(nNgE)m&LZe4!oh9 z83OD6n^*ZdYztF1!>{gW#Jf1AkoZ70@)N*ji7l>oo?te{B>iRy^D%W_-|8lEdu;d) zJ^;4e_y4toFD`uP^_qeD7+X$U!8;X+BRV9MGs;$46Y=J@RIc?TL``wgwsU};r-kEP zjoNw0){DQJ87hge0YmB~NKY|bU!epx{>EPVU+ssavhP|Crc1ujMog{JW=?JIA9F3K zU=AecF)DK^RlN8fFUexl?s$%QVR9~^HNUVgvoM1jbfdt1V(7W?z-+vy+@mMtzAAEWpJ} zPOQ&;qoJ(OzeIicl6wNm8j=fLKNxVWe`Gb}Z8fldqnuh=4Rgs@IHDpRzeg-vAx&)? zMb`!NFuk!F{?qh28{d;U9It5#O(NlL2V^2WGHyW&9)Wk`HQeYc8z7tuV9~+DcwsA4 zzDk?=9LF6pY+WZS+s?&!@r^`SHLk*kilhJ*rVzK_=u_5yz#!N?l6f6wcGLYviDs+4 zKDY(Etk%o2`Oj9pZ#u&bE@-316COv`mF&5%knJ09KqkOgTANs}o}(Q297rgnm{V6F z``E-LQ)@iy3672vw~M1s@Ctn-lc1_1%t zl4veDskYt!Sq&?UrOKozzjYUk#;J5zTGgy3P-gn+i|nXh+|u#s-xZk6AHT(0a_FBI zQ0}iJ8B@(&rwS@4&34eG-b%#Kj4N9$rLq0=7LqA!S8hjbvBWE~c9f+yVi%~6ioRTn zlh5Q|j;|k|v`LL?b@tlw7An_>t^YkcyjFD5sadcFH_si!4w2AV7$$x3DuYOYA zU5~I$v~5epdu)lj66*cWzU$kkT3I1DhMXIESKUjv=kBLk(UQ;#ynCjwyRqH*P+wTt zsa(zXXZ1&oSD8(s)8W>s-l+4j$5YR9nx6uvK{kd9?OVe>tr@F~_t_8b^~_2E-T_aO zwm%&Jzh4y)pHlH#pM_y0m(@4?W0i8Nuhdrs%KvjRX`nm9iOQSx&9)GHp`a*=)Il|C& ze1*WB@3c7toqPqdIahe1- zYfcxJ{CqC+>306tVE!rn9@aLh@G00?#AoysU|;8-#lK&x-*2LW`|rH{e-$1=aLkTT zOvb}3rR#$o+v77%^@m@li5$!SRoWb~SHC}cvp?tZD5qPi2XW4M46n^$Cp&_AJ$g;T zH7lbz`*D`GUM#l(cGE*bUJ4Zj!<^%@XBH<-?5!SS)0_#5Pj(8zGAsDB+XLJ?bNUbW zgEgG`T;5_&>C*8Fhc;dYr}#>=b5lEG?&OaV^ZL^98gImk8@_19p7zXo0>i@f(M5tG zI|7WBjKtLO(zQy(YJV6~TrW2p`jS!MK8V)PcYW+<;g%zWgne%A?4)4{|IGBgIZi1K zmGFtYaP9M^QwbKN-3gOvlrYpyl2k`Uy+UJ%|;bEiOH9fq(*=q>;+(_Q2 z82Ct=<$zsDp7DOkiv6?~JO&((Bqor9Je?l9)oe+sR6Y(bFN-ee5ZI!I1PZEK=$$N; zb2r5!Hta~MG)8j)yH`eKn3icfPS;Pd4sOX`3_DaX&nt}Bs&A*F?Fl5&SXv5S=5*v2 ztSf-zs}sLU=l(wKxx6qyfO4Kg`Ew+P)(FpfH(|6J4+j6TwksY_pOHFkC4Br(ss!&llry&6h!yBcCiww8~KR#>$>yQ@I;hU|j;R@}M1s-oev z(T6pzyQ{QsN6d_HORRJG4ax{g2xGUBA>Q7?KY68853hX-PIDd{Yh9#pYdS$uX}ss( zu6Chi*jt-@d!Kj(?nMJ}TP37w^Nm%8-Uk4WEHNV9w$se?Th*A=&@OvKD^O)6F3>mY z)aYQIbeKE%i!TN1Nvt!cVjT_7SzhvBIb2$(H0r#OG}%=d>Sxq(P`?EK#b%!TB?lS? z4uck;SkOc$;fBoy{>JFedeM3}Sb4Z8_?5zt%J5?|Ry&RjXWg0K#%JhP5DA(v^%y1d z>@PW>4m2NX4&8>@Z6Iy{Ht0=IojILRSd&vetK(!M)n)2>WqSSAR%(@Lm1vc>BjrM` z_*Q|Q_KPeSHK$$;i3p@9VF^K+Ox%-lqj4h_yCVIG-UeKiATi-K@ih4gVVR8HQ#z78 zk~~s458g;ahLLaUWLeCf?)<%1n zx|w>)y32a(e-w1p@{Sl&v*Fv_l?E?`l>ER)Z%SIXi2X2@D9`l6^z9E}%`<99^EW(o zzl^(QKJ<~v$b6s?D8QaD&(!UNQK%u=BiIe3=!)D1*t|FTovLdko!!EVHT3CU9&#dr z$S!E;(~l7`^AF7!^Vn>4RDrgA|9)Xh$U(4v_pqxuT7~fBq;S%FvqXH)1k#kSg`i9( z6_OW&@F7H#nR_B`lzeCzAZ7_I2*G5=1nA3T(4OoS`A-Z#;0kaBBnWJm5H?YI6OZHn z2*@Nr%qI2YJ%el>5ZU>=^A~4YXIy6?z`o z_Z(^Cg9$xrWQwA`+_KnHl(w9Jf`E9dNGXjWr6IW?HP<%+kQR^|)BwB%-hw*NNzei) zgs5K>eZ`)F?pP+{-K_)uGc_gw8}BwmHb_n0smM`+Fk`8a$;Aof3B?Ejgi?fxgrbD9 zgp$bQ@EFn2%e-nJl2d9Q2`M~ zswA|p=nOy@6a$LCL1)5rj{NqSsCltgg;w!aC107R*gK?itqqC|(~VOojf7rpUNAib zTu8QvcKjya_&xC>sUy+<8?#W5IFJm=3RT|F-rzCeaYlD$b4Fwh#FdpNEkK_J;X#9; zlF(i#6_oM6DnwKj)0m+xu`I_(O-!1EJ`DT}GQt=JVL@}DZ((jGSmy*A&KnI-n+=2w zSre4=0H_+Y1}X;~{^Uaw>OdpG2%r%ndl7w#zr#7FJI6ccoj|r1N2*6*D#(n= z+FP`eV2ALcQR{yDKSztdM8N-!6>=p^Ah`W~SbRCKY zjfIMA(3*T>P2mCKiV=zz;KR6wmGXw z_^Y16tsAfJX45pk>d3m5C!>&J2hHBlnLuO>ABB;lx-dP_iJZ=1IQEj24|o> zG!#k#5=L7B31bA1y#RbAeC2%swOhbOtjQ27=~^1TZ-O902@=TET?+}*1BMSe8{t}7 zhp*|yv-J-0$h0rV7fYbwmMMrQ^uLItZvA-IEe|$8trZE^?Zw9Wg2D8Kv-N9mvGqp| z3NVH-1a1<2o}ip{YVQ9Odsbe2A4ZY39H<@0us^h+ttm#ZOvG79)>1Eivj_b@<^feg z8iFyIx+msF)r_`+kOBNA2+WjVfpAZTrieQ=Z!z7dvNA!?MnT{IFV@}yDvoW779~h< zcXvt9MjH>oC0K$x1W9mr*G2;b3l1Sba0u?uxCMd+Z(M@A{^le(_gp#m-T(e))Tptk zF{*0U+H43=3%|h6XG>kd1`vb4D5o%pAtih|L!#)Go9x zjAvBPzk-L|fiuAR;03S6Fb{kOpi!g?ql={(3le)B76>gzPy!8m zpwOSy@1MZ%3-Gu1xbhfdzEvA*5G((6}}H!#8tw!1m%Ow!^}a>U`OyV7!~XRk%Z7gOpW27MLzjL z@MpCMw5(2S||pA{-Ddz4^YJX45^Cv19Vhqq`)BfSUOdS4;=qQ zckuRffL|bwW(dLR!4d}_i~k9s|5-UPVbek+0%UNW(7Yg$ z2mvMogMjaWk-#)y05Fb7<~O~Hhna+BgE@Zjm5@EGJ@wprdY5+*}FM>OQ3im6zc~)`6d$HIO7acx71vNURwA&4@M)nUYL| z&dcJW{9t*RwnI7uF(d{B69p54lAHoZgh7Z~h{en5qVC|};BXnYgE2%2C6i2qUWi7B z)9dZUmxHZku8u`iU(uVu1I$iQlzX6;*#+aW6_9W^6m{9S4o`&H%f;>0McP6A@^MFQ zr%8uN=SqhtdJN`NFk=v7$OxtqiV}tr@;%GV@d0~BE1H2H-WPSNWK;z-L6wQ8=nl{6 zy-X$@l3|Ai=g>8$0N&!fa{XM&TIj~x@?X7QbK9GUy@h&|jI&g^f^AJjH_ts%Uz6To6!T%tg5P;M6B$}_>$1=Dpng2A>vd;6#P4<+R^4j)l&8vO;o~iz zcb{{fiIa()iMx2Y_Km&XLHmAqE!}{sT0`Po>^dy3-FEE5x@@F!^K~&ZtJU813$1CP zWYpA9EI3eZm>Ad)VquH~)v!>R2aGN!lq{;)3>iKN1}i{}Avnea_D>F#AO>J_@CF!z zDzZ!V1P+r5gAN1sgUJ@gBFD5$s`qBc@lPC}st*`{fgDT!n%RTg*L&@D zGifyGxBXK4X~2xx05Nrm@2qzRE_aL|*v1HlOcil%k(!db+duXwzkd5?J|wANy+iHq zTewi1gIo9~QbC%LS&V3XQ2BpRK{*wqd%1Yg*!DDHUI{NQ;I_nW1rHgOU(?u&06@tK z3e-MQH)$6Lhw{Jm{2&z@of!@xHX&}*{N{dY$_J%d!Pe1x6#*UD-o*Q!%bf=y>MD_E z0<%Bb!H;@iE^-%qf%r!#^Zy8DD~KHI8^#`Xk3+pz{RgGOp7NLlgAyf}b9kTxF8>O9 zLIQm>+Cs^RN&qK4Y*>OYhj}z=Q*l!wXjANj&I7v{Bm%Yp|KZ_sL@O982rKw1Fe}(A zC@VzmVE}#w(EorBzqrCsQuuW45C9>(;YmoA0wO*&J32Ima6%l6dF>JG>Fx0Wq0myB zQWsp8peZvaHK#ZyHYYnL`4_Dgb`6q~7NE!pPTO&N->QxigIyH1h!um|O0SOFN}EA7 ziKT>{FznkT5s?H!f3TJiHDlaEl82IB5$u-g7V4I1rx~}*HxU=_ zFVZgfDgrMsu^}wEQrxuV-AHSU+oJwsAev#o`vtF)bjdBHDmg?|jGV4N*&0;lpleDd zeDMU3Q9$dmjWn?4^ouXT?S^Xx*K*11>N8r`arvFBeQ!b2iZ>}g?Tm3g z=8}Td2XC-lE;b{uMYbwtu@}^n$^Ame$Apo>wa;mVkmSt7FyyS*BK|F)3b}t_J-oCrQJ~W|GN|Wq8h0DFLM57KBGdr4sdL4*E zhbwf6yAP~XHuP!7G_HsC*oQF7WR&hJnJJ`_ZZShDbhOGF~1r=Ib?o5 z+;Q`vm4bnSS{n}w1I=*q;fAqblStT37xVs9lXb*hi zQ2dF=kD`^4exLr|3o|VV8Z{fD%jK{_9PocgHK|Ni5!m1V0|y67jFX0UV>0T z5ugF2jP`aU6sR=7sjDs7{mRLwCg4eS+lW3tOPE^I=M!Jsr{3FN*<9saK9xe4K5p1) z=Q@-39pPHt*-FAX20eqkg84(sm$nuQ{pc~|z^25>md$XT@YdK_&=2q8_2};;R=evy z-zVKh3EU?3+zQv-E_tUf`dQ20q5}B>bx1pD-Mp<3?ipGgC|5PvkE=a;EhW9my1e(^ znhP3y{l33|Tc-ZT@q&+&(VMihHJ*6ptGb&`YO}LbO2w-UgDtsSPWHUd9OoI|D#J-9 zRjkGzyHu;B3C`;=K4tm@UwnHyv;?m5oqwxxwUqga58owiKax+(C#YzmB4Uzhm*q@| zs;yToQXv;Zc{hjCczyhSFU(&sxc{3jXEvq-NOl}YwhInn4q@S$sypY%iA1#+z77qM zhb|RU-V4)9BPo?=iRm7sT^N^jCwOxAXz8G2yi=B%5K9t!xtwY}oB`F(v9_99bJ)?! z&v?{w4#1#imx?=8U;7FRPi=ivaBe5S-BBopE2+cw5;G zIDzZ13(`ZtXpCbQA`T)p9KUbRWt&MWdG3}te{|9PyMRdbwT}U4()s#`At|B5Bm9V;>4u#a&JyCDR$v75HRqx5h-)NC=D2;XCIFzL%$;O=KZT978bcY z632%A&xcxBg{@Xk?Oy6fja5h$Xyg^O7YG`q(e${4>j!x=e*L;1`JBH2uRv-TsdcOi zZy2c|uK#4^o$ZFLZ@Dw*oa61wP;ZU+Mtny2r}*>TpX%oZRh}%9>Zmi%eXxJmD8XC$ zlF_+g1_S;**e8lVaP5_?fx*z^0Wxc0n>K$QdC!%~#aci6{;9q&i6i?sThsQIw*I;k zxxFxeavE_;@mVOztdp*U(Uar2HeZN|Vf%SCY@*dFScjSNP#SKfvm2@$c^RuNnlN%RVrm>(zUPI_SYx|1@! zut^+U)t)vRMz8SX7FbT_E)%U!=VX7P=W9CK`?2KiY1!fno{Zd?Y7(eG zC1CBFS2Z%tcO5XDME)gcLVjl=dCUp@oO2j@XFl9otXiDL(qi{teQ{^qs;kqKHk_vTmDFoafjeh`bl}RK z?C_M9~6J;mJQp>KCwv>^f;zU=%iuOY;l5?Aylttddbki_>Hx@hA z4u}wx6!t(Ig5X9lFGL&?^NeekR5F(25n4NhMBP}4ahR$_+AH&+TtXBej1q~x*wAT8 zJP;0a{xSL|4=`X=g*{Bz@`ES9JYe0w&OiL}T7m!YR_C~wfALo_xFc92I6GleVN)Q! zupw|NSO-iQ#tNSOqd$m0dj!t(Gn)pCg?OgVD(Dq2hcH{T1E8Mg5L^gW3S&{B8m1nm zAEuSUT>%Lg!vbP~naL6g4F9eepvI7q0LK;Q94i8J9Yznn1*<}5(6|rLpi~s~lZ={V znLGXd%dbFU zUsh`hbUhSlY2%w7a?PHvKs*EcOjDxU!(cq8C5sfdVTAR-IzPy+oNxeq`WWHyru{k)q1i$;rnId?q39;YMwrwR$rK zIZXvtx^T(d!)DA684mfPj@Z2P^~)r}1dCY&1==H3=2HW8g<+*3Ok`0eb}Z4IhZX_2 zb~K95sXycpD@r+jc_#lc6@r=A|9w+d4m6+PAPD;1_ zfL6swon`*sAYrgoAsEPFOEUlE;YK`+9JM?i0 z*70ruO~RdJ-y?YV)?*G5-(L0Y<~#3M=X_G@+T&Dj!jJ5Td8wxPsfPK!GLfD zjcU$Xv*P)_kfJS(S!Wf()AA=Z-ER%JY}ZQ|bLoelHQXM(H9)NId_f`UlDlF)Zhk1F z-xhHJSIeires^>;tb@H})-}oi-a@?|mFg(EWnTLb!yY?N0Q7|MA-%Fmy(xNk<8o=> zU;$e6dIr+Cl}o!B*1}ke4Mi!4d|D9xwjf%&0OVXjG1+6#lXo6ExC*-1sXOt7tc=|| z%Xs+qoN7giu265?Z^DhSxtim?Kc7XXk z@=DYl?drmI+0=UOrp%TSyW8L1tg2R6+)^u_#`i2Lzmo6+{W(B;gX zYpdb=n}W=y{e2-z7rp&PY~F5$X}naUHYWj^4HfVW)0!G|<{Mn1~=hoxx594p- zZRLlqLP$ya5rs{@(>c}*fMme#TcAh3jKB;^3 z5`g{<0LKSmn2Xf0W47s3n2Q#CM`3SM^D6xM5C&T2J|d>3G73jZb5O=W04!}QZm>#_ zCoJG^nnC6VEE%20nvsMDH2NI_ZU|)%o~CHN1J@=Hy&LKNl3r8jxyt0DA0me#N{7TE zJ%krH2FsRSfwqU_iOZfhew2r}KHcmW_*=|nYd4k&5l1pE2$gDz&m~_y|0DDM5y*X^ z4+~}su8vmztQGh*QddU@nUE!qP@O$&rnXohiu4K*S;UH+(1#`Xw6J*Puum2t@uOs{ zUvWyll30Hw_@Ny1@+(Dt4%}bERWu)T;bbcecTbOqL1xQ3YI#Ojzi0e9hSn|EgPvje zscw{|-G7ad9iy2M?_S4z9pctwxZ{tZhe+!yDncO$Ze&VJvO>YZZX^*0Xc=9OZWIxR zu=-$mH{!A-wWg4%!^d~gd=>Dv%hnHML9x(-c!5Q^Y;pr9e~2v7Wqv_suq5vlTy}`w z(&efd@;gTSyw8|Ib>BOCb@eYOBdDpMPpH8093oO^+dH1uBGiD@WzMY!lg7lEOD_w; zXS}Jti8J#a*fbhJGiNuJ;9TXr>w$?XYIMTM*1KnhBvHn9d1*_=CoKYNEJA700?vT= z5w76qh7WLHC#|69f@J?Qz!%5PqSUF1JVQ5c;M_jf1E9ojY!Dw#LW{ z9kXtT`w-!#7|a7~k?#Bpw9FM$FHqS5PfHKx1-9t2`N!*`o2QbY*~PEV6Z#7Rcx>ff z&A!++)GH1>t$4&Mq4zPB%$mhIz+)P3hV@;IaxGYWn&fi&@vO0+Rg9B#>V!?{`#t}7 zictr4z6H{2LxbH=r-)A>V~>DXh}qaz?$$pn<8-y0Or@ zIM8~KBEd|N-9!p)2z6M01en?We?;dwL}XCx$zBhf8#@W1=k*8h=8Rpi0<1|y#huK_*>eNE>H|sNWCKV%h48B z5O2aV4;%xc%9$@{m7m*md|QiSj%$S^RHN%6*cOEO_DtH%=q=qR{DAZW#l@iSzOGV} z`N7#^kt`dM1&EIlg)ZBX`NNWda_zXI+be(=J-Nt=Z6F|Wutm5Tka%bmmUR@RWc0E1 zD25~u;fMWGfh<~qY_5hZ=7wx&$wO_nCsFJn2I878Tb+m@UqQ%DI_o!M9ub9!5k*oH zg&Pq?{}V<{gcz1!b;Ba;0Br4fb!fQu{H1LP$w5VSJf-c`br@47oS&8+D|B%y^q|d! zrP^`Xw3pPObJ+{-wWTKq&(xv1u29THTyr4i)lp(Di4As%Cqvgjg(m)A>*Bwl)VC*9 zGobc>ZK3n}g374U7VTbVR(tZ?jnt6uCdtafJ)j!Tc;fgo-6HfOOWIlgXP_u{ZUN!U zAuMT8B1~ciX@NdK!dn0g8~`a0051+e>jc2k0#I@Rk4*p=8_QmiJ@C4I7Og+3feQ{_ zEYGX=)&z88`jP`kIq<)6kaOA5+H?%nA=E;62f;t;;9QLf%vRXuqCD-`_d3bmLwtn% z5CMdkMidm?w8=5jheQNR_Co%Qhj;{#H!K}oZUiIC?kwG?ZrJS0rcD7Fha~zvq!)s} zVYATX=|)MpB<>XybBM{(#dv|2x$NlW&whyC(#>~4uxLd5J4tT>3}Q_pmLJsSYBucC z9Gs`QD4%mkKIcAun?vw67h|%$K@)Sw1kNg~VH%0l1b4ji(==MD391#Sq@3rd0==fo zWtu{8$#xoB(8zo@Ku?A8pEu!;Iwoi5H%+%pzYfbgJrR0&s&m0lMP4mOG$3Ypz zgOb}{i**H2=&_wh_X>1;f3kWN2dV3_&0L_TJ>_~9-ucR3;QEuN?)w+u_8S7v4}3a$ z>igI$`Ut4%nRectPc&yge!Hw>e{d~a;>5liz-(|V`2J9GK8DTfpR2$?BP-CNY9Nh9%?h*OuA2oa;A90w-MtfjT<8a+stn0Wh>}64F74UQ(1PuYQv85StPurJ!ima zla7`--SjkRj&O9pfX}$CfWoTcp3|@7csFlbnD_lJb+rN#7T;GCBl{z0S5dKRdpmma zeN%686OX4rkjPu)$A(N&w9w|EY)R6M3M2oL9{*~N&{*J-+B;~je$IOOIa}au7Q@?Y z-fctj;)v675#F|tf{3Vc0Iyhc(Az%a&pHafj3su0GO?O6Pqyok&%N-qCr@P})Y|>Q zpq=*cD0Xzw9izaPM|{CA>^>;m4b&qLxUW#U~MDdGVLe1=ay83~vzNzDbN z+N0WZStIL@6$qEh9~CB8mFqmhS3yot`K_x|P^(oCcMSj32v$K+70BC0FRemY%js)6 zCVP8$rwL}4VW1}aD^kxA@OMW3vqb-Im`aQ0vSS$TnAr@(IqBlx4E-gmIEchK@H#oj zXgP3lIS5wlD29976xt+_N7Q9RDC30RjFGcB=2?^tgqIctP3-xmWPB57#5J?#D-Co$ zxW5%ii4yAnGn}IcdZXy`Dv=bMApOm#Z*~I1ZIo4T<}Y0*9wr*TXZ^Giza)vkFYNoG zwLL@YNCBdn=VC%7-$oYYaF<17yCGV;GFqoyWSdN6hh}7_JCJe(@Q85fxo!}sjwoqK zRX1e79-$OWryE>kk6zm4T=zTT%LH@bzv^1Ibuwty9&r!+3-?R*miw8dN? zi>?sfgp*-@B6Cooa4+x+F9-tI2>rwo0#OVyR6Z`N>PE`j5i>v>bp4C$pl0W-Zs3lc zFtkqDw7pX3bQ)}nszc^mfezg)2k!Zj%bdR;0JX}VaId?$4%6{~L(X25qAf5vB9sFY zI{QV@WuocVa|oZ&8SjRIddN+%Oe_?!Q9;DMB-s@7R0QRhSNTUyL33%c=kYX_a|QMv zIW<)A;9vfsy2%gt{t@h-_WwrOl|*zHMZIyuExVRik}EB8-NHZ7BKUu{FaKIBdVV7M zm#T&qi?q;V00r*D^p@lUq81 zH&zBlB?Xt*k+di}N1s}!%uBbPOS#mwgpmPRrGf;0Teav^x1_av3J02^qk%+uV!G#GTs9W{5DTSU+(}Oh^>18t`2`xlF9R!2=iFz<*egx<40A zALKmFT{)6o$DMSTJYpQ&jftN5)}-DiguzICUchOtIy~pAe}%AYwae^%7cyIXx3MR> zy}OXobJj=!Ia-8C8=X9N>M3&&`5HbWy*I!oYOz@ZC(F zsm~KPX64KeVuUo$zr7vKm8JLnu5>0R>k5)}wX3ilNbDP6=?n3>5201KWlp8rtMjsK z+6{4=`SGJNw4~ogC28J{ZT^B)_`O=grKaTU5LBScVA?wSy|z+?z0EINDYoh6jH8-`-b}ZE{$GwrOl1@-KXeU=IPqzHFe6lmn9r!Gp{i) zukkXk*)Xq($g(93k|fseeP4CBl5;bb z{o8KwN#8mlUDEOjJ)hRrRXN*KXiO5>BvU9)zfqKfX6{4t;lR&(IcVCZ(&_9QCZ%l1 zV_3#^YOmT+I@HCC%DPZ$FeEJl2A1zu4}fcSiw`(FPNjT>HB-d0-&;ufjZ18-f7ow&}1)p9oeV)=h(}DcN>N@ z8f+Q|ozc}BY!(NdLmLK*^)M`xI=`=#yYT-@Q&gaDa%RTV>|d_<``2^1%1aZyzrC*{ zH10L4W4D*n^Xc__)JZ8keMT=FG~>x8=|cad8N)d9VZkvaJ&BlkM*nlEB=@(3jq~nC|27U$Dtl#Jp*`5x@xvO{Fyulj>;z_#3lKs?U zE?ZxbdbE*1G9Qt+PJz{fv|ebC-4s{LMfi)ApqQ3S>0t=nkoFP2T=ZBwa9cgl?W54C z8T#!++i@lGKHNfO@5 z<2{nz#^d=C-e%+Sxh+)N5xFgN+t3!vHovIEi0$}}l(6XbY3>5YHi8O!q=(9QM6N#0 zsgX)1)~T#YCdFxr3VYO5KmmL7Ra^nIHKj6g3GndA)#uy3R4Jo84N+ka^Dr8Z$k8V| zjVr*6xC$yzioAMXFcRtUW}HyM+kPC{i8td(lEVA>YMG1QRmw{kBa6vqlCBWc)s+%N5#EW>LDtU-q(NEOG$5!|Io{% zm;BeAj&X6gY-MBrIGZop!vQHzZLigRTu?%o-)ih>tA$5% zl-14?#Xn8Ty@P%*R?1sz{J6iwFzFZ>FiVoPy~@z;3$(Gy8;oAJ!> zs{s{XzF*^7UnJ5x@pmH>epUB(Bb4v;_ksQ|@Ke^D@d~zF{YdcTH0PD0%#Q^6N+9Eh@3Wq-3uekjCi7eZ=IU-NC zzvYTBZ#(`o+}#s$Hu!#L*COL~RPF-Zc1i96{kFN(e@&AF4R4AwNse~U}P|J4I( zr!49>iL8qzneYwvZKdmal$gDB==xa0&%efHJDY2wSUDo5INToP=s-eW|2%GkzV-=G zO6p5M-xOW_C4D{rT1{`CJ5%4aP)1rhZ{J>(?EVqIyQ~P0`6X{7zpTr3O#GDTQ#yAG zhuauIjs7PFf{Yshs~%+&uM|p?96vK;BKDmc|0rSJxDi#Bhl7WK{vg3nBT>U(1MgT(Uh2Uc}*+PN;WZX=8IP4 zDC9*AStNaA1^O9_(wUzS?MP%3-J?iZ4k0)u+WuI5XJ#jvqUGF#U52flP(lcQ$tRlZSjR6yF{evr z(HXl$jN}Q!_fV(e_cD?mpVKU?5y!M7l-R{Rmv9c0+9>@$tVyu?As)cZKV!E;Ehn8u zmGGPOCwd1T4eJUQ1GC|8@W>ZN?n7AOqg4OqHfjHnM@q0|Ft%{_s4O-NB#+PFFdwnQ z?88QAQ=yVQqCnJ#yTi257jxpW!@0mXD0?Q$Z1q^m-=s}z3Egl~F6Xo@z0G||)bG+- zg47T1KyAtS*&D{Ua2;)(Z848RLkr-L9-TiT^!G*FZaUzxLjxk-pepYLmickm;Q--o zU@qtnFb+hNe}szqi5McS*X+S@cw~q&252gD{WK$jQ-|+ zg#MW@t&bKE?$BO2CbBj zGYu07>*)_~hY9Wf;}%#2xJCF3gbX-+czwh>bT?8rLN`jL_U}*O)?upKbeBjBDL5$W z2nygz;Rs+*{Uu?_)bKT7$KmAtA7^2=Inc4tcHmI6AU@y3eV&dr8N|U5#7eDzOf8Ef z_B;%`BY>kisF1oYmg9AR`#4-NtcSmdAy3?dvPfv9+*g ziMDZXsuXlyH^3elJiA5N^nCTnAaP4WLR-=Rzc8XD<_o^c;FWs+7jy^v_p@0Wwi2If zEv20t1!EMNIZw0aO_sdht(>L#=zVNRqh$75gXR43?oGZz?+c*^1>(rol*H%RZ_Gco5{|qz?O9s2KUu!^X#TR|@#UUooBuXW z=G5o9f>X=p*{48G@&K}HOQatoy(gqJ6Kl|q%`2~0pYmtH*N47KjE&zD*N&dwY@|t- zB$U*aUKH0B!?==_s$z;OI60f{fSG%tfaQ$ zqQrMU`~fdGx?vh?Je;&`(`eCBgAhHVRvG!tFESCE&|rBh70^*L0r z@C`Ubu+;W)_RtTM`7vtVql}%FwFy<-sqZf6E7{+RU9&+AX0OAuM8Vhf;)#N$^)D0oqqSP( zxA)_&_)FcJ=7HIDEjl&(v1=4s`t$=uuTxf1X3yokn^g_U#-~ERMekg{zMiOT(oUS} zJtEOs2X35A$$S6YZh`#uEe17|@75k^QM_Lh(^_|K`w{xFg}TsIW_wn~#sm4ZvvQt8 z9X5$?nOlT@EcgUz?6DuE$hljYE0r)$P*p1>u}~J+r0ia=b(mee!{wm98*||Jc=477 zdqZFY&7JWmGxYBJqvjS_C5LTNQ}1K6)AY&~(-7!~?0gWm@!QH{t~bm>i)|+&%}_zkjlGiP06)yZ|UT_G*Rn=!;5E9?wTmdU^*I zZ+NCmi0ox%VrY%H^7^1%>crlo?>34}9(zYqdfw_oj|%(jo+6qGFT$1FR{8iu4|ufD z9+~tmhTQCr-qTk4R2K}D_&%R3OUb^=fnF`Y+IMnfB*xUcmC5wPlBqT3&X;*-jXULx z_%zA1S;1jDA}f$mvG}%1NOY>#gK=28)VEH*HGl89QIdFe-!{ke(_IpbFKvyFw=aDJ zc?*?Gj(F?$qYD)!^bl;$@VQ;EidSCrv1Ox}R;Y?qY~#qh0vbUC_}S4tXHU1+sY;~Z4DMi&80A;CsVK#3 zW=&wUe{K>#o=@8+Xd1r9cJSIS>mn6fo9B@$UKA^>$3GbP6zRJJa`?XH95A2Sr5@mH zdadeaom2~7ye#jgS=sffj0L}@-8EXa8f9O#u}RYKv(XfhM}aGM+rkXc#N;jZ+n%h} zg;AOKZL;iXH91MHcS~Tv!D+Z}Ov`Mv{_8k0uk?oT%X~p;bCX2HT1jY| zahfb$|E0Nm^l&Ll`Wiv{u|m4xi}b43H)vvep$C$z3k*>gg_>a(_H?g579?+VVSq}a3{Px z{1v)-UBr%Dcwr+E^VORs%0jle$`f4x`Ev{sxft95-~Kf=vrFU8Or|sBt86=Lfpb-A z&-b)bm_OzAiVfcasL!2~X1g3TJ55;s}3D!hq zk8)Ol~gIBPY z+bn?-R_FY^Kkxy(X5E^HLeT&dzA+QD#?hMkOB!39lFg!CiWjq3#05pJH65-4Sb|L( z7j1fhOoAWS`wcNhF5XSg6j@lIeE_UfbGw+Zp4}V24?kSsb6L^->{=2u$>7z|QN>TS zkbTm;i96a(9tJ)SoHN)n(b(P zTbfBZzrel4b`!5Oqd_;9i@xQkdsHEAabeZ-VS9wt3-Vfm{Md?^_Y;Sgv;MUTvut)= z(2p>R_>fP3^k(F5p)yD#E9)$-HSzhrsSglMcJ7@L6kZYvz>S63^2jGl8|h$`aGHAq zimvc%$Mb%^i=N9?8-M;d&6dqXiKJ>zHnRca79=dY>ZTOusR@vtbTMJST!kIQ@az*# zTWJP2e7asP^8$P!Xrd60a9B6P-R5+xLTVxJ1yPr8zhe!lNfoefnT9yHCJuKIq)(+B zqw`9euY0|8blMvkE7W$HOc7{b-yBS{m3MIZRO!T4u_=KzaE-0`a)X69sfX(PbJzg6 zneO(+tdsgjBLm;JS}g@$Z=X!hy)1iVwO2Tm%&wmKnQ(GFBX|Hi^jsUF+&zkBPQ9n+ zF(*94f6EdSG8W_8rZvs9dcm@q=0os&__hxdh)NnnmKmJ3azQSr5#!h&Gcj(>zmgb$ z>ZfCxp~s>U!!E=yA%Z%EREj%C5?@ssN(fM58;rkgIe+TrExbfl-L*HOoTP>M;^1gK z?G#3R-dG3o-fA1nZ}shRmL+|NAl-2Y2$!0BtoM>}*gkdmywa&g(`oX9K>G&)X472( zQdzGB?Fgl#DB%fj^8LcpL&ev#FO_OHA{M?~D6qOJ3C}08D=L-2kPd3&17nqHKisC& z0#DR7gv>y56(jyn8W_zH6R`DOg+5uG2Rz@4Yfzorle3%ku%HJLiX4wY^XK`O(el~w z*~LKX918QB+cf4+p6_(TPP^vAa;i_L>NvgfIb81L?1YylQA=g)te4dNXDu9V3JZOF zM!uYz4cn&C)bJ0Av0EErWmwk@M$JUpT5phghG>R zqn2Ho(X@+Xp+iBC>m1F8k878Ec;C5v&8I?X;cYib=A!$aMbE9F;{rxBV%vJg0(nQk z9O*O0;T@Rab&X$Z$x#eg+=**yD{XgP69|_YQN!#doMk1|50OCge}fkX^f;Wnh)LYf8v^h zGs=&o9wr6^dFKA0m}dTNk7mCYXxzKv1`U@l`)+ekkllv_i{cTg-8T6RiP<;`>w z5Y4rUmddRaEm)#Ws_vI}qn>ZGHgFxIo>J7_yJ4okw9ec981GYDH*#F{UFCWj*UiKm z9lGwx#M|$5A8Rx})*!DlpjOFq)XJ_Safc#sv8Ci1elRs)d~HCOA-e4(l*5#oKAiu4 zC}w}oyF=@Sg;2f~HMM?IF8dX4aEJ8?70nx z4ZZgZUGmV6w5Y1OU=&K!yHLmpmkRns%JM-9p=!Q^h)oFkrrNNHYmFKDM#tqbA)Amd zc*~7#*83d!+3a|`5Z7)tlJFns%(Ar?vjl(_R0*Hy?lQ-Kq(J@%?MRV?E zU2XJXd`yKAp4f-c-GImQlI~iZa%_RWq)BmIV&tqtH%U>54ddJytq^c z%azF0at>(81hg;$T4Fd_2suPDDdVoDHRCbFzT316jN+Mg7g7O6<}`nyD9YYK7-RpQoTJ4A=&9PT6O z3F3^GSYh^YGdGIy7N^#D-J=1a`Kv z^~i7|H`c3slCFw%#$%|b#?Jik<+}rrWF|k)@by#tm{V;p8s_Oiz;e96Hw7&oFPLa^ z$D^={Fn#AJJu4Opg^sSz?UZjQlPbPZq@`K$nN=oz5XtI#2E-S}dqIv*5%gN-n<}oh z#an~xD`?bK(L=w$$22CXN0&nsoPj(GHjlHiO-nw#P?RunJyEsHSl_`2`XVC{5&3pG zD3K&eiN52zvQWT`<=xU`*zvSTkfcc0PA+m3+yatUXPUlttaJtTDUGs8VF~CW+ahSA zRe2@$qQ#qIsq;12FsdbeTi899-_r8K4R zoTw`S)rdudEy&_%nCJypvPQ4@)y#VyZ!W>QTk#HRQ=?~oY>6SBUvZdVb z?N3^^&c>`PqZX#+N;1O`?I(&VzBEvS^F4X_p0deY(3vqe2$CsDj9aL_$ikhAqIqSB z%5)2rIJQ)q&c_$Q5?%iJlH;R=9Hpy$hlLFA-*Ru(BW{g_&rOE?{GOe$QY%4gT&KZ4WgfcdDdVe* zzLg#YE`-)PSwu6||bUtLK zjrHd2loLRv5Q@B|<76Eq4kU{SWL2Kr&2WK`@=%5kB^;Sl0I)p3b{4_cm^PN0+OJIN zLXr7h@mEGQgUUdG(xJ4kOo0PPFii(Pz8%Xx?U7Hh7yqb=2Ug9|UUgXDD}-lhwTs2c ziz~Q;$mDUxXVupbzq?J4h~EL@Fm-av46{~VA@yUT(P*9$iaU@KNi-20wqEqD!NsvA z5Q`Gm!z7Rs$wkFT+I!|f;5>l~eI@xcdjnkVH=A52$^$=C0c8r_oThp0g4_U(qyr~e zUEd#hD6ery^kZgHR>PIv0vtevPd427HmHb&K1$lfeF~T^k*c_T^C}y$B@&SPF{V!S zah9&4Vy^;Hp$gU%2jQ}FouT0OW}voyv`#T?Ds*-%EfKW=&yo0 zK8UVjx|b;ibF}0ZaV?!Al#Zc@Vty1S-A97I(Rd^2rxw)Mw33l^zFmyP3okyuETbV! zt+eV%{(MoJt^m5ukVmP)D`45T{o|l+xC~|-Q%Awuh3Gv+C9(FjTD&GsG48KXOz09Q z(cBuZl1WE9^kZCwG<)ZCRRBF=N?^h>H@wnc7bmc6hsBh zmR2eC%MD59Jp~f&F`nCk1nX}X)0&%=Y9)MxBq*-uIJff--6W%D!8w)?^|tfu0dSC#SPisZD@y?2v$#vvr89)Ks|5Sb#! zXE*vKYKm;xG@%`>R@qBa%y=I>M*vfu@(J+O#DILO24#ebP$~O_-o(4Y{S{R=NZV>#>%T~zdnD&bVaF@f8;>Qr}JLDv7XO1 zhVzH1vAwn)0)*AJ%we!6=!5$8GoclolAGsP@?+a1Sot?o%;q;jbsmK&L%X48@p^&% zsXmF;az&P-C!?j#{gO9CWjWmW6Q@*cuGY#2mU~p%W7|?#?5>#1w$3kOa}Gvc@7!Al zd>&|~?ceaM%VsR`3G)2WD8~P-Cy1}a2I0_bF{=MM;2>|pnrgU=LQP+1h&BWn(h6W| zm~PeMuMb&k7~96+zLvaa?QgtQaLS)Zry54vRb@lx7>!qV4RrHeQeRsZQ~x6Ov;jRl zx@5MfiMMz0&B9{L;>aW5y{Y_NB>nvh`MWprcbF#)xVyW%U);S|ad-ENySuyV#r>iec;tI|KVGsjIr~g0xb@O6w`5Qk(AO@KXJ0=ML0O*1fj@eYN%6{eHOhV*hih%Wc5- zHn59%6aH%JRUl5;@BKbBVEhxvOc2ZCZ8O<-NK!Bq!j9N~$rbS7t8)3FH^m^Fi>K z#&^)e%Q=Nb8pRq*A^BacjFeu(M7~9OJdi~OBaO{w&NN*}Ns@h}NF&X9R%W*7hdi3O z%JdC&j$h7?k|R;Nh|!LKM}Ywv>ZM3sdEL&API_wUlXoZ6!=^S#45Ig7yGh8Qhw0&X zDzlkS+j$f+=pUV4?&iy!951oQaigByM)P%)Xk+%P!dwxlc-Q0B82X%@N|_!N>$;-G zmzivtreBSltk=T*cXIM&_^l3kifV$O;6%^#KBqWEgRJCn)f4u>>6SkeVbrWh<50If zOf^I-{#f=umyz!MQEG?@pqBhjdnUG3uMDm}J@UAJ1;7AM+rRjHlzwE}6ft^O!>08> z+2atvGzDJz`TE&Qm$vA0nnQbUpKo_;d)hNMBd;U)pkTRDslWmQV77I(`K~zJ5g=b7 zh!89Y@gvP6y!``B5;BFq&~L(^9?orm{U>dtH)I}IALIaOV@`9Z&>rON^li+)grRow zu&y7U_+yU_K>O%NaimwZWL*Bd+LN>mvt7UKwT+sy{mG*n%l?}-(gl>9za(!W?B%Cy zxG6thf6k75_`q%3E12Jmxyrc92yi{c-EQ4m-RpdXB-@tui0z++zBu8U!?XK|_q+!j z!&_hwKoi4l!MsCD#s4{nTk?bNx&7fQP>T2Wvs<8D0KXq|+%=v(V>1fRSCNb2dWo{` zwQiGb*Q-zN(2&m%%zeTDy&80DC>#Ax?bv{?0QmM#b*QAMIau1CpL@XDj8`yM%vaR% zeOEA8{)qNJaXu#pCTv4pab9seQasXM#dO1`pknzK=0I0`UeG5s|FkB^ED@02O?5@~ zNcBiL+!oXVeUL-M;#a9pX%6KjK>Yaqk@k`4QSOR=+vG~>%6FSp-jT`?dbEdH9)7hO z>i5?wXg7bkz@Z+D?Y3>-?#OMoZMkjYA6Kr2#M1EO`cxdK^MN+{?8~T|@V0PnfnGgk z-N_&GBiFqp*kdw|tquPY#$w zzX5&nkE8;<^}n?v0Y343>inDq&EUV~@9Q5xvmz{jtB!QiBRdWC{E;+lGh)Ukw}6+P z;vVde@l#!GZF63cJQ6-~+i!)R1=I^5aKL{gFF?4A=<5IL2oAo7d>hXmrkQXZi4TDf zo(NVhfH)vKK+j*TyG!7Ty0FMkLmze-v9(9=O4gpR83q8&1Ks&G3yL4A3(og*HPnNp zJDif>2k&Y?A9MK&&=0GI_^V&vw&j(rJw`JI;5*Nk&QC<}Tks5l@36km)d5Qa_pE

?3YdxXeuOAbu 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


dhM#HN5(^+qy)hLBP8q3qdt7* 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 z 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�U&#t8#s3T+{&#X-7@l>^KCJSUMka2{A=#B2s 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 n9?Q+v zNY;cwTbOM0))4(*MQxz?p`!h)S{iA-p=+T0++|!7g zbuZ6Z^3KoguIgO|X!!E`gg#D8C>%RyVs7`l$HqcsX8^92&l_73aPs?=tV-=DJR4Y)zc1iKj2S@lmW8>=GrX!} zjuiYY=ABU8gS3}b0#np7grbCO5|}t47%}Sj&3-A%agWPalZua6Pa& z`Nb|p#`TF_W>jA>VNps5h@_T0{$@ZuK_w8Ke3OX+?S!R?i$BAASnU?(I<8m(?? zyZzXEd1hqYP-*|FrVH{la72vwB89q4T6@NEFg+<%5{*p#{1$zWoJZJTg^*`Wjol16 z4Zim4;h3H(Ulmm(B+dtBNQ>@J;|JXvIt#&d*s`sC^eauA_o@1#sW#E5CZLg_$qcY# z1L6dGIU8loaTj}{;S7`{EnN)t7c13^MD7AXuxlMs*wie{#g>N)czB`|i2?u~p-X`m z6U9hKCAr&=oD8s8*}7((`%_~Q&TxS}Oal!z2p<@1LUSqVB5HCBEbf6-!@!F!Rn2#i z^f4EcE`hCf_4?!nppI;!PYTP-ikZ!MA14HVZ&O8q$-O87@Tqm10xmS>PVC@UWwCNa zW@=0cCQtiC(APy;8t>(sb?=8|Lf*jwOo^va3U$9VzdA0t(#Q03qDA6-uQHQseWE~L zL7$gB*L**!7V2bsHd0 znF=_GFL=gtm!GQ8i)ng{9J)5^(2)7;Rec z02C8}phRmh4_dt9*5EI1Jv-ZNdkpLe{n;4iAeXOML`IUzKdS0Fvqdsga z_7OHlht5|wAy&G$tx}3wqxEIPBazqbDw*yGLNznP?*ir|RMiv*QQRsaSwH`QCmP-( z=Fv|^P@pe{R+tdW{S>NQ$cg@XeMKFWkQc58m`8MZbF$rowcuW<^3iKFF7E-O_xI%P z@M(_`V<6~B!=^d>p!hi>{YqjhC-6oC{ST^Gl_vpV$_glcps1eP^k}0u8bb2@mhxkT zGzDOIvf8_^Qt>1>m;#((LwYTD|Ec@FH?2gkL7dbCR5K_Ix0V23t&jFXa1ScWCuyMY zM2?|J>N}zkzMV1(bW&)!81(9B8*R%2dJUxhttCjbca|#T1+4e_dWioes!H}S#)Rtk zY|ue{B@OaeDAo^U5O&R_g+KeuKUN){s3tH4aVAsJZ>t5q0<0#|MA+_F9<%4Lr>cAz zV8t0c$1?aguN)wz`$J|AW|(QdkH8b7^HYBT;5P0MlowK00A_6ALfE_SA&n9prX|Py zgJaA`MAFw?Vc-Dr#YFnYk&5+_t2jJHy*_0YMn~ka>ArjR^JWq>w@8&P0ddR(;0N*{ zrgeLq1cU-y3(hquq1U#2{oe&*_>N&>A1L@3QcD} zWYB9%wf;EUv@?jk2?-;)%3B3s303(+CTVD-C7SI)m$Hp#ORBOa4yZ6AWqNO<2^l0k zdiwcu{BicjGiG|&F;(l6)x1K$+xs-?#TkT)oVPf-KtB?={TUVMEC8FsN4hi7Yc!34 z%ed|=<93?pa=@Kn3vFa#_uo!Hd0^Sjp7R46#B!P0Ts-i%DFbx9@rFC3N3cN#BM*Af z&oq$r(4p6gbGQ;!5Kj5B!f{yEneQW$R#h=(Gax9TpEvkTw7N)2`kBh+0cjo8(W7)$y7xxf5R{Zt$Qb#cR+jBk_4j%I%+q4Mu)_!m z9)`%x<|G-I0PF94=ajy-Q(X+n+A)$oVKinl3I7vw*xra%H>sB+#UkaC6zdiqr<|$g z3k_v&lX@_NV=p!{;=uFTx(Rlx>S#FpE&U96i1EC@c}$0q@9f5})5EB@p@}WpINQ;h={pv~sdnHBjFG=Z1(@ zOGvRov9Uob9e!MeiO^2B*jC2@v^R_qZi9HeowSa7 z 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�A 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